Features of Java 8

Introduction

On March 18, 2014, Java 8 was released. It brought several new features for productivity, security, improved performance, and ease of use which changed programming in Java. These features include the forEach() method in the Iterable interface, Date/Time API, improvements in Collection API and Concurrency API, Java Stream API, default and static method in Interfaces, and many more.

Features of Java 8

Let us look at all these features in Detail:

• Functional Interfaces
• Lambda Expression
• Method Expression
• Stream API
• forEach() Method
• Date Time API
• Default and Static Method
• Optional Class
• Collectors Class
• Parallel Array Sorting

Functional Interfaces

A functional interface in Java is an interface that contains only a single abstract (unimplemented) method. Along with a single abstract method, functional interfaces can have multiple default methods (interface methods with some default implementation, they can be overridden), static methods (methods in an interface having implementation, these can be used in implementing class but cannot be overridden as default methods), and methods of the object class. They can only exhibit one functionality.

Lambda Expressions can represent an instance of a functional interface to create an anonymous class and avoid bulky codes. Runnable, Callable, ActionListener, and Comparable are some of the examples of functional interfaces in Java.

@FunctionalInterface annotation is optional but it is a best practice to avoid the accidental addition of abstract methods to Functional Interfaces.

Lambda Expression

Lambda expressions are a means to create anonymous classes of functional interfaces easily. In other words, it is a concise and simple way of representing one method interface or Functional Interface using an expression. It is very handy while using the collection library as it helps to iterate, filter, and extract data from the collections like arrays, lists, etc.

Lambda Expression provides implementation to the only abstract method of the functional interface without defining the method again. It consists of 3 components, Argument list, Arrow-token -> and body.

Let us see an example using a Lambda expression where we create a functional interface and implement its abstract method using a Lambda expression.

Output:

In the above example, AddNumbers is a Functional Interface as it has only one method addition which takes two parameters n1 and n2 and returns an int. In class LambdaExpression, we have both the implementation with and without lambda expression, commented one is the implementation without lambda expression. Lambda Expression has three components,

• Argument List - It can have zero, one, or many parameters as in the definition of the method. In the example above, n1 and n2 are arguments/parameters.
• Arrow-Token - -> symbol is used to separate parameters from the body in a lambda expression.
• Body - This can be defined without curly brackets if we have only one line of code and with curly brackets {//...} for multiple lines, as in our method.

Using lambda expression in Java 8, collection processing can be done using multiple threads. Previously, to perform multithreading, programmers were to write long codes. Now, using lambda expression and Stream API, we can pass the processing logic of elements into methods provided by collections, and now the collection is accountable for the parallel processing of elements.

Method References

Method references are a shorter and more readable way of lambda expression for only calling existing methods. They are compact, easy-to-read references that can be used to replace a single method of the lambda expression. Besides, in the method reference scope, resolution operator(::) is used to separate the method name from the class name.

For Example:

can be rewritten with method references as below, without passing any parameters.

Let us use this to print elements of ArrayList.

Output:

Method references are of 4 types:

1. Reference to the Static Method defined in the Class

As we are referring to a static method, we don't require an instance of a class.

Syntax:

2. Reference to an Instance Method of a particular object

We use the object of a class to refer to its instance methods.

Syntax:

3. Reference to an Instance Method of an arbitrary object of a particular type

Multiple objects of the same type are called the same method using method references.

Syntax:

4. Reference to the Constructor

Referring to a constructor method with a new keyword.

Syntax:

Stream API

Stream API is one of the important features of Java 8. All the classes and interfaces of Streams API in Java have located in java.util.stream package. Streams API supports iteration of the elements of collections, where we can process these elements, perform operations on them, and store the output. Streams are functional i.e. the changes made to elements do not modify the source.

Operations on Streams are of two types:

• Intermediate Stream operations - these return a new stream. For example, filter() operation returns a stream of elements satisfying the required condition, sort() operation first sorts and returns a stream of elements, etc.
• Terminal operations - these give the final output for a stream. For instance, the collect() method collects a stream of elements returned by intermediate operations into a list or similar collection, forEach() method iterates through each element of a collection, etc.

Let us take an example of a list, sort its elements, and store it in another list using Streams in Java.

Output:

• In the example, we create a list of names. Let us say that we want another list with names in sorted order and all the names should end with 'a'.
• So firstly we create a List called namesEndingWith_a. We call stream() on names List.
• filter(name -> name.charAt(name.length()-1) == 'a') returns stream of elements that have last character as 'a'.
• We sort the filtered stream using sorted() method and collect(Collectors.toList()) copies all the elements returned by sorted().
• As we can see in the output all the names are sorted and end with 'a'. forEach() method takes each element from List and prints them using System.out::println which is a reference method.

forEach() Method

The forEach() method is defined as default in Iterable Interface is used to iterate through elements. Collection Interface extends Iterable Interface thus, classes implementing Collection Framework like Arrays, Lists, Stacks, etc. also extend Iterable Interface.

The forEach() method facilitates functional programming in Java, i.e., we can use it to transverse elements/objects in a functional style or while working with stream API. It takes only a single Consumer object as an argument like lambda expression, method reference, etc.

Syntax:

forEach() method takes action to be performed on each element of a Collection as the parameter.

Let us take an example of forEach() method to display data:

Output:

In the instance above, we insert some random months and numbers of days in the respective month into HashMap. Using the forEach() method, we iterate through each element, and check if the number of days is 31; if yes, we print the month. Thus, we can not only transverse, we can filter elements, and perform some action on them using the forEach() method.