Author: admin

This blog explains the Java 8 Stream API and most common usage. After reading this blog you should be able to work with stream API. Java stream produces pipe-lined data to perform different operations on group of elements. Streams internally iterate over the data and perform operations, then returns the result of functions performed if any.

Java.util.stream package was added in java 8. Java Stream API package contains classes that helps to perform various operations on streams or any collection of objects.

It may seem that Streams are similar to Collection. But there is a huge difference in both the programming paradigms. Streams API is not data structure. It iterates over the data that is used to perform different operations. Whereas Collection is in memory data structure which requires all data to be loaded in memory. Stream does not store any of the data in the memory of the computer.

Another noteworthy point is that,  java.util.stream is a package and java.util.stream.Stream is an interface.

Java 8 Stream API workflow

Java stream involves creation of stream, performing intermediate operations followed by terminal operations on the stream. This process or this flow is known as the Stream pipeline. A general high level stream work flow looks as below:

As we can see, in the first step a stream is created with the given input. This input can be any type of data ranging from arrays, collections also primitives. Then this stream is passed on to the intermediate operations. These in turn produce the output streams and give them to the terminal operations. As a result of which output is generated form the terminal operations.

As we can see stream has 3 steps
1) Creation of java stream object
2) Intermediate operations on java stream  
3) Terminal operation on java stream

Step 1: Creation of Java Stream

There are many different ways to create streams like using methods of Stream class in stream APIs, methods using collections and arrays, Special streams (Stream of primitives), Stream of Strings, Files as a stream etc.

Let us focus on methods using collections and arrays as these are the most commonly used ways to create stream object.
These methods take collections and arrays as input to produce streams out of them.

Create java stream from collections

While creating streams from collection object we can use .stream() method on the collection object like lists, sets etc.

Create stream from Array using of() method

While creating streams from an array we need to use use .of() method of Stream.java class

Step 2: Intermediate operations on stream in java [ps2id id="intermediateOperations" target=''/]

The operations which returns source object (stream) after processing are known as intermediate operations.(Also known as Non-Terminal operations). As they return stream object we can again call another intermediate or terminal operation on them. This helps to create chained operations one after the other consequently [Chain of Responsibility Design Pattern in Java] , to perform multiple operations on same element. In chained operation the output of one operation becomes the input of next.

Most important point to note stream operations does not change source objects, it returns new stream with updated elements.

The most common operations on java 8 steam object

• Filter : used for conditional filtering the collection objects
• Map : convert object from one form to another
• Flatmap : Used for mapping nested objects in java stream
• Sorted : for sorting stream elements

Java 8 stream conditional filter

Filter() is most frequent operation required on java streams
This method is used to filter elements as per the required condition . Predicate function is used (java.util.function.Predicate) to define filter criteria. Predicate function can be implemented using lambda expression or method references

In the above example we are using java stream conditional filter to get user having age greater than 18

Java 8 stream Map

Java stream Map function is used to map object from one form to other of same or different type. It needs Function (java.util.function.Function) which takes one input and gives output of same or another type.
We can use lambda function or method reference to map object

Note: -

Flatmap : map conditional or nested object

Similar to map function, flatmap is also used to convert object with extra feature of flattening the nested object. It means we can use flatmap() for mapping nested objects in stream.
We have seen that map is used to convert or transform object from one to exact one other object.

If we want to transform from one to many or no object, we cannot use map and we need to use flat map. Also if we need to transform nested object, we need to use flat map.

Flatmap is very useful if we need to map objects conditionally without using filter function.

Flat map transfers each element into streams

List<Student> computerDepartment = new ArrayList<>();
computerDepartment.add(new Student(1, “Example1”));
computerDepartment.add(new Student(2, “Example1”));

List <Student> mechanicalDepartment = new ArrayList<>();
mechanicalDepartment.add(new Student(101, “tutorial1”));
mechanicalDepartment.add(new Student(102, “tutorial2”));

List<List<Student> > allStudents = Arrays.asList(computerDepartment, mechanicalDepartment);
allStudents.stream().flatMap(l -> (l.stream()).forEach(System.out::println);

//Conditional mapping example without nested list
computerDepartment.stream().flatMap(s-> (s.getId()>1) ? Stream.of(s):Stream.empty()).forEach(System.out::println);

Sorted : sorting stream elements

Stream elements can be sorted by 3 ways

1. Natural ordering :- stream.sorted() The objects must implement comparable interface for sorting
2. Using Comparator:  stream.sorted(comparator), we can create our own comparator or we can use static method provided in Comparator interface, like comparing, comparingInt, etc
   1. list.stream().sorted( (o1, o2)->o1.getAge()-o2.getAge() ): Sorting by age using Lambda to implement comparator
   2. list.stream().sorted(Comparator.comparing(user::getAge)) : sorting by age using comparing method from Comparator
3. Reverse ordering :- For reverse ordering we can use reverseOrder() method of Comparator.
   1. list.stream().sorted(Comparator.reverseOrder()) : natural order reverse
   2. list.stream().sorted(Comparator.comparing(user::getAge).reversed()) : reverse order by age

Step 3: Terminal operation on stream[ps2id id='streamTerminalOperation' target=''/]

In contrast to the intermediate operations described above, the terminal operations do not return stream as output.
Terminal operation can produce result as primitive or collection or any Object or may not produce any output. The intermediate operations always precede a terminal operation.
Although there can be multiple intermediate operations, but they must be followed by one and only one terminal operation.

ForEach

This method helps in iterating over all elements of a stream and perform some operation on each item.
Takes Consumer function as input which contains the logic we need to implement. We can implement the consumer function using lambda function or method reference

Collect

One  of the most commonly used terminal operation. It allows to convert stream elements to other containers, like list, set etc

ToArray

Similar to the collect() method described above, this terminal operation collects the stream data into containers of arrays. In the example below we can see, the stream data can be collected into a generic array of objects, or to a array of a specific type eg. Student [].

Note:-

If we do not specify the class type [eg:  toArray(Student[]::new) ], Array will be created for Object class

Min and Max

Finds the minimum or maximum of the list value form list. We need to provide comparator for comparing the elements.
We can create our own comparator or we can use static methods provided in Comparator interface, like comparing(), comparingInt(),etc

Count

Returns the count of elements in stream as a long value

Reduce

Used to reduce elements to single result by combining or processing all the elements.
Returns optional object means null or something
There are three different ways for reduce operation

• reduce(BinaryOperator accumulator) : Takes the binary Accumulator function to compute the result object and return the Optional instance

  Integer[] noNumbers = {};
  Optional<Integer> reduce1 = Arrays.stream(noNumbers).reduce((a, b) -> a + b);
  System.out.println(reduce1); // OUTPUT = Optional.empty

  Integer[] numbers = {1,2,3};
  Optional<Integer> reduce2 = Arrays.stream(numbers).reduce((a, b) -> a + b);
  System.out.println(reduce2); // OUTPUT = Optional[6]

• reduce(T identity, BinaryOperator accumulator) : We need two parameters, Identity which works as Return type and initial and Accumulator function.
  Computation logic includes the initial value while computing.

   

  Integer[] noNumbers = {};
  Integer reduce1 = Arrays.stream(noNumbers).reduce(0, (a, b) -> a + b);
  System.out.println(reduce1); // OUTPUT = 0

  Integer[] numbers = {1,2,3};
  Integer reduce2 = Arrays.stream(numbers).reduce(2, (a, b) -> a + b);
  System.out.println(reduce2); // OUTPUT = 8

• reduce(U identity, BiFunction accumulator, BinaryOperator combiner); Mainly used for parallel streams, Takes 3 arguments Identity which works as Return type and initial, Accumulator function and Combiner for combining the results of different streams in parallel processing.
  Computation logic includes the initial value while computing.

   

  Integer[] numbers = {1,2,3};
  Integer reduce1 = Arrays.stream(numbers).reduce(0,(a, b) -> a + b,(a, b) -> a + b);
  System.out.println(reduce1); // OUTPUT = 6

  List list= Arrays.asList(numbers);
  Integer reduce2 = list.parallelStream().reduce(0,(a, b) -> a + b,(a, b) -> a + b);
  System.out.println(reduce2); // OUTPUT = 6

Match

This method checks if the returned result matches the criteria. It returns boolean value (True/False) depending upon the result.
There are 3 matching methods that are used to match the output with a certain criteria.

• anyMatch : Check if at least one record is found
• allMatch : Check if all records are found
• noneMatch : Checks if no record found

anyMatch() is the short circuit operation as it will return true once it finds the first true condition and stops further processing.

findFirst

Returns the first result from stream in optional(null or something) type

findFirst() is the short circuit operation as it returns the first element and stops further processing.

Fast track reading

• Java stream produces pipe-lined data to perform different operations on group of elements
• java.util.stream is package and java.util.stream.Stream is an interface
• Stream is not a datatype
• Streams API supports serial as well as parallel operations
• Stream operations can be classified into three types namely : Creation operation, Intermediate operation, Terminal operation

References:

• https://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html
• http://tutorials.jenkov.com/java-functional-programming/streams.html#java-stream-definition
• https://www.baeldung.com/java-8-streams

In java we refer classes using variables. We call methods using the reference variable of class. Wouldn't it be great if we can refer the methods also? Thanks to java 8 feature releases, we can do it. Method reference in java 8 allows us to refer methods with class and method name directly.

Before going further, you should know about lambda expressions. Using lambda we can create anonymous functions for class without creating object or implementing. This helps to pass small functions as arguments.

Method reference is shorter way of writing lambdas expressions. Sometimes we just have another method call in a method body in such case method reference is used.

Where we can use java method reference

Using simple Java

similarly using lambda

These are the cases when we can use java 8 method reference so that code will be clean and easy to read.

Syntax of java 8 method reference

CLass :: mehtodName

Object ::methodNam

Most noteworthy point to notice is that in method reference syntax we use  " :: "  operator not the  " . "  operator. We don’t need to pass arguments. Arguments are provided by the context variables.

The most important point to note is we can only use method reference for lambda expression having single line of another method call.

Different ways of method references in java

Static method reference in java

As we know in java we can call static methods using class name without creating object. Similarly, we can refer static methods using class name.

StaticClass :: staticMethod

Example of java static method reference

In the example we have MethodReferenceTest class and static method print. Print method can have any logic. We are just printing message on console.

In main method we have created an Optional variable. Then call print method for the variable using class name.

In the example we have called print method using lambda expression and equivalent Static method reference format.

Object method reference in java

In java if we need objects to call methods. However if in lambda expression we just have method call using object, We can refer such methods using class objects.
classObject :: methodName

Example of object method reference in java

We will use same example as static method reference, with the small change. First of all we have removed static from print method so it is a normal method now.

In the example we have called print method using lambda expression and equivalent Object method reference format.

Object method reference By class type in java

Method reference can be used, if we have method calling from object while object is provided by context.

In the other words we can say the lambda expression scenario where we are just calling method and object is a input as from argument. Then we can use Method reference using class type. In this case the class type of object is used to called method.

ClassName :: methodName

Example of method reference by class type in java

In the example we have person class. Person class is having method printDetails. In another class we have main method. We have created an Optional variable of person type. We have to call printDetails method for the object.

In the example we have called printDetails method  on the person object. The method is not static. It is not invoked using the class name.

Reference to constructor in java

If we are just creating new object in lambda expression, we can use constructor reference.

ClassName :: new

Example of constructor method reference in java

Similarly as previous example we have person class. Person class need a parameter to create new object. In main method we have Optional variable of String. We have to create person object from the name.

In the example we have created person object using parameterized constructor. After that we have called printDetails method from the created object.

Fast track reading :

• Method reference in java allows us to refer methods with class and method name directly.
• Used to replace lambdas expressions having only another method call
• Syntax CLass :: mehtodName OR Object ::methodName

Introduction

Java 8 Optional class was added in Java 8 release under java.util package. Java 8 Optional is used to represent Optional object or empty value instead null reference.

This will help to avoid null pointer exception which occurs when we try to perform some operation on null reference object. It works as container or wrapper for actual value which may or may not have null. We will see how to use java optional with example.

Why java.util.Optional?

While developing any application or program every developer has faced NullPointerException. Consequently, in order to avoid that null pointer we need to add null checks which could require nesting of if statements. As a result leading to ugly and unreadable code.

Let's look at the following example for better insight:

This code could lead to null pointer if person or person's account does not exist

we can handle this in the following ways, we shall get into details of second way later in this blog.

Up till now we have understood that Optional class helps in avoiding null pointer scenarios. We will learn about different operations we can perform on java 8 Optional object with example.

Methods in Java 8 Optional class

Now, let us look at the different methods present in Optional class, for more details click on the links

A) Ways to create optional:

A most noteworthy point about Optional class is that it has private constructor so we can not create object using new keyword.

First of all, we can create object of Optional class in either of the 3 different ways

1. empty(): static method which returns empty optional instance
2. of(T value) : static method which returns optional instance of specified value
3. ofNullable(T value) : static method which returns optional instance of specified value if value is not null else returns empty instance

B) Ways to check value in optional:

Some times we need to check if optional contains the expected value or not, we can check if optional object contains value or not in 2 ways

1. isPresent() : public method which returns true or false depending on value present or not
2. filter(Predicate<? super T> predicate): public method which returns optional of value if matches the condition else gives empty optional

C) Ways to get value:

Optional class provides different ways to get values depending on requirement and scenario

1. get() : public method which returns the value if present. throws NoSuchElementException if empty
2. orElse(T other) : public method which returns the value if present else return 'other' value. Used to specify default value or null if no value present
3. orElseGet( Supplier<? extends T> other) : public method which returns the value if present else returns the return value of other. other is functional interface
4. orElseThrow(Supplier exceptionSupplier) : public method which returns the value if present else throws exception. used to throw custom exception if value not present

D) Action if data present:

There are many scenarios when we need to perform some operation on data

1. ifPresent( Consumer<? super T> consumer): public method used to perform some operation if data is present
2. map( Function<? super  T,? extends U> mapper): public method is used for mapping of object from one form to another if not empty, returns the optional of new value
3. flatMap( Function<? super T Optional<U>> mapper): public method is used for mapping of object from one form to another if not empty however it avoid the nesting of optional

E) Other methods in Optional:

1. equals(Object obj):  Compares 2 Optional objects, returns true if they are equal else returns false.
2. hashCode():Returns the hash code value of the value if present or 0 (zero) if no value is present.
3. toString():Returns a non-empty string representation of this Optional object

Fast track reading :

• Added in Java 8 release under java.util package.
• Represent Optional object or empty value instead null reference.
• Optional class has private constructor so we can not create object using new keyword.

Introduction to Java Functional SAM Interface

Interfaces having exact one abstract method are known as functional interfaces. Also known as Single Abstract Method Interfaces (SAM Interface).

Single abstract method interface means, this interface must have one abstract method. However there can be any number of default methods.

First of all this is not new concept of Java 8 however, new annotation @FunctionalInterface is added in java 8 features.

Adding @FunctionalInterface annotation enforces that the interface has exact one abstract method. While adding @FunctionalInterface annotation is not mandatory.

Functional interface annotation enforces the rule of single responsibility. [more about Single responsibility principle]

Usage and Syntax of Java 8 Functional SAM Interface

We can use functional interface like any other interface in java.

However from java 8 functional interfaces are very important, because we use functional interface for implementing Lambda expressions. You can read more about lambda expression here.

For writing lambda expression we mostly use functional interface. Due to many functional interfaces newly added in java 8, we don’t have to write a new functional interface while writing lambda expressions.

Java.util.function Package contains newly added functional interfaces which are commonly used.

Following are the valid java functional(SAM) interface examples:

As the rule suggests, functional interface must have exact one abstract method.

In contrast we can add as many default methods as per our requirements, because default methods are not abstract. This is the reason why some java classes are called as functional interfaces even if it has many methods.

For example, Java Comparator class is a functional interface even though it has 7 default methods.

Overriding java.lang.Object class method as abstract

Overriding and making a method from java.lang.Object class as abstract in our sam functional interface , also does not count toward the interface’s abstract method. Because any implementing class will always have implementation inherited from java.lang.Object or elsewhere.

For example Java Comparator is a functional interface But, it overrides equals() as abstract method

Java.util.function Package

As discussed many functional interfaces are added in java 8 java.util.function package. Let's understand more about function package of java 8. These new classes are also known as SAM interfaces.

The SAM interfaces in Java.util.function package are manly categorized into 4 types

1. Consumer: These interfaces have a method which takes input, but does not return anything
   Syntax: Consumer<InputType> object = variable -> method body;
   Example: Consumer<String> print = str -> System.out.println(str);
2. Supplier : In contrast, these interfaces have a method which returns something without taking any input
   Syntax: Supplier<ReturnType> object = ()-> method body;
   Example: Supplier<Long> useIdSupplier = ()-> userDao.getMaxId()+1;
3. Predicates : These interfaces have a method which takes input and returns boolean value
   Syntax: Predicate<InputType> object = variable -> method body;
   Example: Predicate<Long> evenChecker = n->n%2==0;
4. Function : These interfaces have a method which takes input and returns output
   Syntax: Function<InputType,ReturnType> object = variable -> method body;
   Example: Function<Long, Long> square = n -> n*n;

Each of the above 4 categories has provided variety of special interfaces for most common primitive data types.

We can use Consumer, Supplier, Predicate or Function interfaces with wrapper classes, however using a specific interface makes code more cleaner and easy. Let's see the different variants:

• All of the 4 categories provide special interfaces for int, long and double, However Supplier provides an extra interface for boolean

  • IntConsumer, LongConsumer , DoubleConsumer
  • IntSupplier, LongSupplier, DoubleSupplier, BooleanSupplier
  • IntPredicate, LongPredicate, DoublePredicate
  • IntFunction<R>, LongFunction<R>, DoubleFunction<R>

• Function provides even more special functions for converting values int, long and double. Name of the classes are self-explanatory

  • ToIntFunction, ToLongFunction, ToDoubleFunction
  • IntToLongFunction, LongToIntFunction
  • IntToDoubleFunction, DoubleToIntFunction
  • LongToDoubleFunction, DoubleToLongFunction

• Consumer, Predicate and Function have variants that accept 2 input arguments. Supplier doesn't accept any arguments so it does not have any class of this type

  • BiConsumer<T,U> Accepts two input arguments of type T and U , returns nothing.
  • BiPredicate<T,U> Accepts two input arguments of type T and U , returns boolean value.
  • BiFunction<T,U,R> Accepts two input arguments of type T and U , returns a result of type R.

• BiConsumer has 3 even more variants which accept one object and other primitive (int long or double)

  • ObjIntConsumer Accepts object of t type and int
  • ObjLongConsumer Accepts object of t type and Long
  • ObjDoubleConsumer Accepts object of t type and Double

• BiFunction has 3 more variants for accepting 2 arguments and convert to primitive (int long or double)

  • ToIntBiFunction<T,U> Accepts two input arguments of type T and U , returns int result.
  • ToLongBiFunction<T,U> Accepts two input arguments of type T and U , returns Long result.
  • ToDoubleBiFunction<T,U> Accepts two input arguments of type T and U , returns Double.

• In addition Function provides more types that accept and return object of same type

  • UnaryOperator Accepts single operand that returns a result of same type.
  • IntUnaryOperator Accepts a int value and returns int result.
  • LongUnaryOperator Accepts a Long value and returns int result.
  • DoubleUnaryOperator Accepts a Double value and returns int result.
  • BinaryOperator Accepts two parameter of same type and returns result of same type.
  • IntBinaryOperator Accepts two int value and returns int result.
  • LongBinaryOperator Accepts two Long value and returns Long result
  • DoubleBinaryOperator Accepts two Double value and returns Double result

Fast track reading :

• • Also known as Single Abstract Method interfaces (SAM Interface)

• • Exactly one abstract method is allowed

• • @FunctionalInterface is optional and it is valid even if annotation would be omitted.

• • Default methods are not abstract so we can add any number of default methods to the functional interface

• • Allows overriding Object class methods as abstract

• • Functional interfaces are very important for writing lambda expression

• Many functional interfaces are added in java 8 java.util.function package