Scribd
Upload
62 views3 pages

Java 8 Features

The document summarizes some key features introduced in Java 8: - Lambda expressions enable functionality as method arguments and code as data without belonging to a class. - Functional interfaces contain a single abstract method and can be implemented via lambda expressions. - Default methods allow adding new methods to interfaces without breaking existing implementations. - Static methods in interfaces contain a complete definition that cannot be overridden. - The Stream API processes collections via intermediate operations like map and filter, and terminal operations.

Uploaded by

bvcecman2
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
62 views3 pages

Java 8 Features

The document summarizes some key features introduced in Java 8: - Lambda expressions enable functionality as method arguments and code as data without belonging to a class. - Functional interfaces contain a single abstract method and can be implemented via lambda expressions. - Default methods allow adding new methods to interfaces without breaking existing implementations. - Static methods in interfaces contain a complete definition that cannot be overridden. - The Stream API processes collections via intermediate operations like map and filter, and terminal operations.

Uploaded by

bvcecman2
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Java 8 Features

 Lambda Expressions
 Functional Interfaces
 Default methods in interfaces
 static methods in interfaces
 predicate
 function
 consumer
 Stream API
 Date and Time API

Functional Interfaces

A functional interface is an interface that contains only one abstract method. They can have
only one functionality to exhibit. From Java 8 onwards, lambda expressions can be used to
represent the instance of a functional interface. A functional interface can have any number of
default methods. Runnable, ActionListener, Comparable are some of the examples of
functional interfaces.

@FunctionalInterface annotation is used to ensure that the functional interface can’t have
more than one abstract method. In case more than one abstract methods are present, the
compiler flags an ‘Unexpected @FunctionalInterface annotation’ message. However, it is not
mandatory to use this annotation.

Predicate

Function

Lambda Expressions
Lambda expressions basically express instances of functional interfaces (An interface with single abstract method is
called functional interface. An example is java.lang.Runnable). lambda expressions implement the only abstract
function and therefore implement functional interfaces
lambda expressions are added in Java 8 and provide below functionalities.
 Enable to treat functionality as a method argument, or code as data.
 A function that can be created without belonging to any class.
 A lambda expression can be passed around as if it was an object and executed on demand.
Default methods in interfaces
Java 8 introduces the “Default Method” or (Defender methods) feature, which allows the developer
to add new methods to the interfaces without breaking their existing implementation. It provides
the flexibility to allow interface to define implementation which will use as the default in a situation
where a concrete class fails to provide an implementation for that method.

Why the Default Method?


Reengineering an existing JDK framework is always very complex. Modifying one interface in a JDK
framework breaks all classes that extend the interface, which means that adding any new method
could break millions of lines of code. Therefore, default methods have introduced as a mechanism to
extend interfaces in a backward-compatible way.
Default methods can be provided to an interface without affecting implementing classes as it
includes an implementation. If each added method in an interface is defined with implementation,
then no implementing class is affected. An implementing class can override the default
implementation provided by the interface.

static methods in interfaces


Static Methods in Interface are those methods, which are defined in the interface with the
keyword static. Unlike other methods in Interface, these static methods contain the complete
definition of the function and since the definition is complete and the method is static, therefore
these methods cannot be overridden or changed in the implementation class.
Similar to Default Method in Interface, the static method in an interface can be defined in the
interface, but these methods cannot be overridden in Implementation Classes. To use a static
method, Interface name should be instantiated with it, as it is a part of the Interface only.

Stream API
Introduced in Java 8, the Stream API is used to process collections of objects. A stream is a sequence
of objects that supports various methods which can be pipelined to produce the desired result.
The features of Java stream are –
 A stream is not a data structure instead it takes input from the Collections, Arrays or I/O
channels.
 Streams don’t change the original data structure, they only provide the result as per the
pipelined methods.
 Each intermediate operation is lazily executed and returns a stream as a result, hence various
intermediate operations can be pipelined. Terminal operations mark the end of the stream and
return the result.
Intermediate Operations:
1. map: The map method is used to returns a stream consisting of the results of applying the
given function to the elements of this stream.
List number = Arrays.asList(2,3,4,5);
List square = number.stream().map(x->x*x).collect(Collectors.toList());
2. filter: The filter method is used to select elements as per the Predicate passed as argument.
List names = Arrays.asList("Reflection","Collection","Stream");
List result = names.stream().filter(s->s.startsWith("S")).collect(Collectors.toList());
3. sorted: The sorted method is used to sort the stream.
List names = Arrays.asList("Reflection","Collection","Stream");
List result = names.stream().sorted().collect(Collectors.toList());
Terminal Operations:
1. collect: The collect method is used to return the result of the intermediate operations
performed on the stream.
List number = Arrays.asList(2,3,4,5,3);
Set square = number.stream().map(x->x*x).collect(Collectors.toSet());
2. forEach: The forEach method is used to iterate through every element of the stream.

You might also like