formula.sqrt(16);// 4.0

The formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simplecalucation of`sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8.

The formula is implemented as an anonymous object. The code is quite verbose: 6 lines of code for such a simplecalculation of`sqrt(a * 100)`. As we'll see in the next section, there's a much nicer way of implementing single method objects in Java 8.

How does lambda expressions fit intoJavas type system? Each lambda corresponds to a given type, specified by an interface. A so called_functional interface_ must contain**exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.

How does lambda expressions fit intoJava's type system? Each lambda corresponds to a given type, specified by an interface. A so called_functional interface_ must contain**exactly one abstract method** declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.

We can use arbitrary interfaces as lambda expressions as long as the interface only contains one abstract method. To ensure that your interface meet the requirements, you should add the`@FunctionalInterface` annotation. The compiler is aware of this annotation and throws a compiler error as soon as you try to add a second abstract method declaration to the interface.

Inconstrast to local variables we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects.

Incontrast to local variables, we have both read and write access to instance fields and static variables from within lambda expressions. This behaviour is well known from anonymous objects.

classLambda4 {

Consumersrepresents operations to be performed on a single input argument.

Consumersrepresent operations to be performed on a single input argument.

Consumer<Person> greeter= (p)->System.out.println("Hello,"+ p.firstName);

Optionals are not functional interfaces,instead it's aniftyutility to prevent`NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work.

Optionals are not functional interfaces,butniftyutilities to prevent`NullPointerException`. It's an important concept for the next section, so let's have a quick look at how Optionals work.

Optional is a simple container for a value which may be null or non-null. Think of a method which may return a non-null result but sometimes return nothing. Instead of returning`null` you return an`Optional` in Java 8.

A`java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either_intermediate_ or_terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a`java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executedsequential orparallel.

A`java.util.Stream` represents a sequence of elements on which one or more operations can be performed. Stream operations are either_intermediate_ or_terminal_. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Streams are created on a source, e.g. a`java.util.Collection` like lists or sets (maps are not supported). Stream operations can either be executedsequentially orparallely.

As mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performedconcurrent on multiple threads.

As mentioned above streams can be either sequential or parallel. Operations on sequential streams are performed on a single thread while operations on parallel streams are performedconcurrently on multiple threads.

The following example demonstrates how easy it is to increase the performance by using parallel streams.

Clock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of`System.currentTimeMillis()` to retrieve the current milliseconds. Such an instantaneous point on the time-line is also represented by the class`Instant`. Instants can be used to create legacy`java.util.Date` objects.

Clock provides access to the current date and time. Clocks are aware of a timezone and may be used instead of`System.currentTimeMillis()` to retrieve the currenttime inmilliseconds since Unix EPOCH. Such an instantaneous point on the time-line is also represented by the class`Instant`. Instants can be used to create legacy`java.util.Date` objects.

Clock clock=Clock.systemDefaultZone();

System.out.println(minutesBetween);// -239

LocalTime comes with various factorymethod to simplify the creation of new instances, including parsing of time strings.

LocalTime comes with various factorymethods to simplify the creation of new instances, including parsing of time strings.

LocalTime late=LocalTime.of(23,59,59);

classPerson {}

Using variant 2 the java compiler implicitly sets up the`@Hints` annotation under the hood. That's important for reading annotationinformations via reflection.

Using variant 2 the java compiler implicitly sets up the`@Hints` annotation under the hood. That's important for reading annotationinformation via reflection.

Hint hint=Person.class.getAnnotation(Hint.class);