This is a 3 part series on Java8 Features. Drop me an email for a discussion - singh.marut@gmail.com
Code is available at https://github.com/singhmarut/java8training
Videos available at my youtube channel https://www.youtube.com/channel/UCBM4yHwfjQ_syW6Lz8kYpmA
2. About Me
12 years in Software Industry
Build software in Project Management, Banking, Education, Ecommerce
C++,C #.Net, Java, Scala, Akka, Spring, Node.JS, Vert.x, RDBMS, MongoDB
Singh.marut@gmail.com
http://marutsingh.com/
3. 1. Collections Streams, and Filters
Iterating through a collection using lambda syntax
Describing the Stream interface
Filtering a collection using lambda expressions
Calling an existing method using a method reference
Chaining multiple methods together
Defining pipelines in terms of lambdas and collections
2. Lambda Built-in Functional Interfaces
Listing the built-in interfaces included in java.util.function
Core interfaces - Predicate, Consumer, Function, Supplier
Using primitive versions of base interfaces
Using binary versions of base interfaces
3. Lambda Operations
Extracting data from an object using map
Describing the types of stream operations
Describing the Optional class
Describing lazy processing
Sorting a stream
Saving results to a collection using the collect method
Grouping and partition data using the Collectors class
4 .Java Date/Time API
Creating and manage date-based events
Creating and manage time-based events
Combining date and time into a single object
Working with dates and times across time zones
Managing changes resulting from daylight savings
Defining and create timestamps, periods and durations
Applying formatting to local and zoned dates and times
5. File I/O (NIO.2)
Using the Path interface to operate on file and directory paths
Using the Files class to check, delete, copy, or move a file or directory
Using Stream API with NIO2
6. Parallel Streams
Reviewing the key characteristics of streams
Describing how to make a stream pipeline execute in parallel
List the key assumptions needed to use a parallel pipeline
Defining reduction
Describing why reduction requires an associative function
Calculating a value using reduce
Describing the process for decomposing and then merging work
Listing the key performance considerations for parallel streams
http://marutsingh.com/
4. Functional Programming
In computer science, functional programming is a programming paradigm—a
style of building the structure and elements of computer programs—that
treats computation as the evaluation of mathematical functions and avoids
changing-state and mutable data. It is a declarative programming paradigm,
which means programming is done with expressions[1] or
declarations[2] instead of statements. In functional code, the output value of
a function depends only on the arguments that are input to the function, so
calling a function f twice with the same value for an argument x will produce
the same result f(x)each time. Eliminating side effects, i.e. changes in state
that do not depend on the function inputs, can make it much easier to
understand and predict the behavior of a program, which is one of the key
motivations for the development of functional programming.- Wikipedia
http://marutsingh.com/
5. Basis of functional programming
Function as first class entity
Functions with no side-effect
A method, which modifies neither the state of its enclosing class nor the state of
any other objects and returns its entire results using return, is called pure or side-
effect free.
f(x,y) => x + y
Immutability
An immutable object is an object that can’t change its state after it’s instantiated
so it can’t be affected by the actions of a function
This means that once immutable objects are instantiated, they can never go
into an unexpected state. You can share them without having to copy them,
and they’re thread-safe because they can’t be modified
http://marutsingh.com/
9. Lambda Expression
Lambda expressions define anonymous methods that are treated as instances of
functional interfaces.
A lambda expression is composed of parameters, an arrow, and a body.
An arrow— The arrow -> separates the list of parameters from the body of the
lambda.
The body of the lambda— e.g. Compare two objects using their attributes. The
expression is considered the lambda’s return value.
As a result lambdas are
it doesn’t have an explicit name like a method would normally have
isn’t associated with a particular class like a method is
Passed around
Concise You don’t need to write a lot of boilerplate like you do for anonymous classes.
http://marutsingh.com/
10. Examples of lambdas
Use case Examples of lambdas
A boolean expression (List<String> list) -> list.isEmpty()
Creating objects () -> new Car()
Consuming from an object (Car a) -> {
System.out.println(a.getBrand()); }
Select/extract from an object (String s) -> s.length()
Combine two values (int a, int b) -> a * b
Compare two objects (Car c1, Car c2) ->
c1.getWeight().compareTo(c2.getWeight
())http://marutsingh.com/
11. Quiz
Based on the syntax rules just shown, which of the following are not valid
lambda expressions?
1. ()->{}
2. () -> "Raoul"
3. () -> {return "Mario";}
4. (Integer i) -> return "Alan" + i;
5. (String s) -> {"Iron Man";}
http://marutsingh.com/
12. Where to use Lambda?
You can use a lambda expression in the context of a functional interface.
Stream interface exposes many useful methods which take functional
interface as an argument. That’s where Lambda can be used
http://marutsingh.com/
14. Streams
A sequence of elements supporting sequential and parallel aggregate operations.
Similarities with collections but not collections
Do not provide a means to directly access or manipulate their elements, and are
instead concerned with declaratively describing their source and the
computational operations which will be performed in aggregate on that source
No storage. A stream is not a data structure that stores elements; instead, it
conveys elements from a source such as a data structure, an array, a generator
function, or an I/O channel, through a pipeline of computational operations.
Functional in nature. An operation on a stream produces a result, but does not
modify its source.
Laziness-seeking.
Possibly unbounded. While collections have a finite size, streams need not.
Consumable. The elements of a stream are only visited once during the life of a
stream. Like an Iterator, a new stream must be generated to revisit the same
elements of the source.
http://marutsingh.com/
15. Streams
Iterating through a collection using lambda syntax
List<Car> carList = new ArrayList<>();
carList.forEach(car -> System.out.println(car));
Stream Interface
Filtering
public static void filterByBrand(List<Car> carList,String brand){
carList.stream()
.filter(car -> car.getBrand().equalsIgnoreCase(brand))
.forEach(car -> printCar(car));
}
http://marutsingh.com/
16. Streams
They support two types of operations: intermediate operations such as filter
or map and terminal operations such as count, findFirst, forEach, and reduce.
Intermediate operations can be chained to convert a stream into another
stream. These operations don’t consume from a stream; their purpose is to
set up a pipeline of streams. By contrast, terminal operations do consume
from a stream—to produce a final result (for example, returning the largest
element in a stream). They can often shorten computations by optimizing the
pipeline of a stream
http://marutsingh.com/
18. Method Reference
You use lambda expressions to create anonymous methods. Sometimes,
however, a lambda expression does nothing but call an existing method. In
those cases, it's often clearer to refer to the existing method by name.
Method references enable you to do this; they are compact, easy-to-read
lambda expressions for methods that already have a name.
1. A method reference to a static method (for example, the method parseInt
of Integer, written Integer::parseInt)
2. A method reference to an instance method of an arbitrary type (for
example, the method length of a String, written String::length)
3. A method reference to an instance method of an existing object
http://marutsingh.com/
19. Functional Interface
A functional interface is an interface that specifies exactly one abstract
method.
All functional interfaces have been defined under java.util.function package
@FunctionalInterface
public interface Predicate<T>{ boolean test (T t) };
public interface Comparator<T>{ int compaare(T o1,T o2) };
Public interface Callable<V> { V call(); }
http://marutsingh.com/
20. Subtle Mistakes When Using the Streams API
Accidentally re-using Stream
IntStream stream = IntStream.of(1, 2);
stream.forEach(System.out::println);
// That was fun! Let's do it again!
stream.forEach(System.out::println);
java.lang.IllegalStateException: stream has already been operated upon or closed
http://marutsingh.com/
21. Subtle Mistakes When Using the Streams API
Accidentally creating infinite streams
// Will run indefinitely
IntStream.iterate(0, i -> i + 1)
.forEach(System.out::println);
http://marutsingh.com/
22. Core Interfaces in java.util.function
Predicate
Consumer
Function
Supplier
http://marutsingh.com/