Java 8 Stream API

For processing the objects collections, Java 8 is introduced. A stream is nothing but the objects sequence that give support to the different methods that can be pipelined for producing the result that is required. Before proceeding with this topic further, it is advised to the readers to gain the basic knowledge of Java 8.

Creation of Streams

There are various ways to create the stream instance of the various resources.

Empty Stream

In order to create the empty stream, one must use the empty() method:

Syntax:

E: The different types of stream elements.

Return Value: An empty sequential of stream is returned.

Note: When invoking methods that has the stream parameters, an empty stream can be helpful in order to avoid the nullpointer exceptions.

Example

FileName: EmptyStream.java

// important import statement
import java.util.stream.Stream;
import java.util.*;

public class EmptyStream
{

// main method
public static void main(String argvs[])
{
// an empty stream is created here
Stream<String> str = Stream.empty();

// printing elements in Stream
str.forEach(System.out::println);
}
}

Output:

Nothing to display

From Collections

A stream can be created of any type of Collection (Collection, List, Set):

Example

FileName: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class StreamCreationEx
{
// main method
public static void main(String argvs[]) throws IOException 
{

// for ArrayList
Collection<String> colln = Arrays.asList("J2EE", "JAVA", "Hibernate", "Spring");
Stream<String> stream1 = colln.stream();
stream1.forEach(System.out::println);

// for List
List<String> lst = Arrays.asList("J2EE", "JAVA", "Hibernate", "Spring");
Stream<String> stream2 = lst.stream();
stream2.forEach(System.out::println);

// for HashSet
Set<String> st = new HashSet<>(lst);
Stream<String> stream3 = st.stream();
stream3.forEach(System.out::println);
}
}

Output:

J2EE
JAVA
Hibernate
Spring
J2EE
JAVA
Hibernate
Spring
JAVA
Hibernate
J2EE
Spring

Using Arrays

Array can also be the source of the Stream or Array can also be generated from the array that is existing or from the portion of the array:

FileName: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.io.IOException;
import java.util.stream.Stream;

public class StreamCreationEx 
{
// main method
public static void main(String argvs[]) throws IOException 
{

// Array can be made as a Stream source 
Stream<String> strOfArray = Stream.of("a1", "b1", "c1", "d1");
strOfArray.forEach(System.out::println);

// making from the existing array or from the partion of the array:
String[] ar = new String[] { "a1", "b1", "c1", "d1" };
Stream<String> strOfArrayFull = Arrays.stream(ar);
strOfArrayFull.forEach(System.out::println);

Stream<String> strOfArrayPart = Arrays.stream(ar, 0, 4);
strOfArrayPart.forEach(System.out::println);
}
}

Output:

a1
b1
c1
d1
a1
b1
c1
d1
a1
b1
c1
d1

Using Stream.builder()

When a builder is utilized, the type that is desired must be specified additionally in the right side part of the statement, else, the method build() creates the Stream<Object> instance:

Syntax:

Parameters:

E: The different types of stream elements.

Return Value: A stream builder is returned.

Example

FileName: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.io.IOException;
import java.util.stream.Stream;

public class StreamCreationEx 
{
// main method
public static void main(String argvs[]) throws IOException 
{

Stream<String> strBuilder = Stream.<String>builder().add("a1").add("b1").add("c1").build();
strBuilder.forEach(System.out::println);

}
}

Output:

a1
b1
c1

Using Stream.generate()

Stream generate(Supplier<T> s) returns an infinite sequential unordered stream where every element is produced by the Supplier provided. It is suitable for creating constant streams, streams of the random elements, etc.

Syntax:

Where, stream is an interface and E is the type of stream elements. sup is the Supplier of the elements generated and the value of return is the new infinite sequential unordered Stream.

Example

FileName: StreamCreationEx.java

// important import statements
import java.util.stream.Stream;
import java.util.*;

public class StreamCreationEx  
{
      
// main method
public static void main(String argvs[]) 
{

// using the Stream.generate() method 
// for generating the 6 random Integer values
Stream.generate(new Random()::nextInt)
.limit(6).forEach(System.out::println); 
}
}

Output:

Using Stream.iterate()

The iterate(E, java.util.function.Predicate, java.util.function.UnaryOperator) method allows the iteration of the elements of stream until the mentioned condition. The method returns a sequential ordered Stream generated by the iterative application of the provided next function to the starting element, satisfying the condition hasNext predicate that is being passed as the parameter. The stream gets terminated as soon as the condition hasNext gives a false value.

Syntax:

Parameters: The method has a total of three parameters:

st: it is the starting element,

hasNext: it is the predicate that is applied to the elements for determining whether the stream should terminate or not

next: it is a function that is applied to the previous element in order to produce a new element.

Return value: The method will return a new sequential Stream.

Example

FileName: StreamCreationEx.java

// import statement for the Stream
import java.util.stream.Stream;
public class StreamCreationEx 
{
// main method

public static void main(String[] argvs)
{

// creating a stream using the iterate
Stream<Double> str = Stream.iterate(2.0, decimal -> decimal > 0.1, decimal -> decimal / 2);

// printing the values
str.forEach(System.out::println);
}
}

Output:

2.0
1.0
0.5
0.25
0.125

Using Stream of Primitives()

Java 8 gives the facility for the creation of streams out of the three primitive types: int, long and double. As the Stream<E> is the generic interface, and there is no way for using the primitives as the type parameter with generics, a total of the three new special interfaces were made: IntStream, LongStream, DoubleStream.

IntStream Example

FileName: IntStream.java

// import statements for the Instant, Duration and IntStream
import java.time.Instant;  
import java.time.Duration; 
import java.util.stream.IntStream;

public class IntStream 
{

public static void intStrmRangeTest() 
{
    Instant st = Instant.now();
    int s = IntStream.range(1, 3).sum();

    System.out.println("Sum of the operation of intStreamRangeTest : " + s);
    Instant e = Instant.now();
    System.out.println("Time Elapsed of the intStreamRangeTest: " + Duration.between(st, e).toNanos());
}

public static void intStrmRangeClosedTest() 
{
    Instant st = Instant.now();
    int s = IntStream.rangeClosed(1, 4).sum();

    System.out.println("Sum of the operation of intStreamRangeClosedTest: " + s);
    Instant e = Instant.now();
    System.out.println("Time elapsed of the intStreamRangeClosedTest: " + Duration.between(st, e).toNanos());
}
// main method
public static void main(String[] argvs)
{

intStrmRangeTest();
intStrmRangeClosedTest();

}
}

Output:

Sum of the operation of intStreamRangeTest : 3
Time Elapsed of the intStreamRangeTest: 41313298
Sum of the operation of intStreamRangeClosedTest: 10
Time elapsed of the intStreamRangeClosedTest: 562842

LongStream Example

FileName: LongStream.java

// importing LongStream
import java.util.stream.LongStream;

public class LongStreamClass
{

// main method
public static void main(String argvs[])
{
// Making a LongStream
LongStream lg = LongStream.of(-7L, -9L, -11L);

// Keeping the elements count in the LongStream
long totalCount = lg.count();

// Printing the elements count 
System.out.println("The total count is: " + totalCount);
}
}

Output:

The total count is: 3

DoubleStream Example

FileName: DoubleStream.java

// importing DoubleStream
import java.util.stream.DoubleStream;

public class DoubleStreamClass
{

// main method
public static void main(String argvs[])
{
// Making a DoubleStream
DoubleStream dg = DoubleStream.of(-8D, -9D, -10D);

// Keeping the elements count in the DoubleStream
long totalCount = dg.count();

// Printing the elements count 
System.out.println("The total count is: " + totalCount);
}
}

Output:

The total count is: 3

Using Stream of String

Strings can also be used for creating stream by taking assistance of the chars() method, which is present in the String class.

Stream of String

FileName: StringStream.java

// import statements for IntStream
import java.util.stream.IntStream;

public class StringStream 
{

// main method
public static void main(String[] argvs)
{

IntStream strmOfChar = "javaTpoint".chars();

// counting the total number of characters present
// in the word count javaTpoint
long characterCount = strmOfChar.count();
System.out.println("The total number of character count is: " + characterCount);

}
}

Output:

The total number of character count is: 10

Referencing A Stream

We can do the instantiation of the stream, and have a reference accessible to it, as long as only operations that intermediate are made. After executing a terminal operation, the stream becomes inaccessible. The illustration of it is mentioned below.

FileName: IllegalStateExpn.java

// important import statements
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Optional;

public class IllegalStateExpn
{
// main method
public static void main(String argvs[]) throws IOException 
{

Stream<String> strm = Stream.of("a1", "b1", "c1").filter(element -> element.contains("b1"));
Optional<String> anyEle = strm.findAny();
Optional<String> firstEle = strm.findFirst(); // the stream is inaccessible here

}
}

Output:

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.base/java.util.stream.ReferencePipeline.findFirst(ReferencePipeline.java:647)
	at StreamCreationEx.main(StreamCreationEx.java:14)

Explanation: We have got the IllegalStateException in the main thread. It is because the streams in Java 8 can never be reused, and this behaviour is logical too. It is because the streams are designed to apply the finite sequence of operations to the elements source in the functional style, not to keep elements. If we want to avoid this exception, we should write the following code.

FileName: IllegalStateExpnCorrection.java

// important import statements
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Optional;
import java.util.List;
import java.util.stream.Collectors;  

public class IllegalStateExpnCorrection
{
// main method
public static void main(String argvs[]) throws IOException 
{

List<String> elemnts = Stream.of("a1", "b1", "c1").filter(element -> element.contains("a1")).collect(Collectors.toList());
Optional<String> anyEle = elemnts.stream().findAny();
Optional<String> firstEle = elemnts.stream().findFirst();
System.out.println(firstEle);

}
}

Output:

Optional[a1]

Stream Pipeline

In order to do operations sequentially, over the elements of data source and do the aggregation of their results, three parts are needed.

The source
The intermediate operation(s)
A terminal operation.

Intermediate operations modify or filter the elements in the stream, and a new stream is returned. Examples: filter, distinct, map, limit, sorted.

Terminal operations generate a side effect or result, marking the end of a stream. Examples: forEach, reduce, collect, min, count, anyMatch, max, noneMatch, allMatch.

Pipelines does chain of intermediate and terminal operations, processing data in a expressive and fluent manner. Each operation receives input from the previous operation and generates output for the next operation. Pipelines allow declarative and concise coding. From the terminal operation, the result is found.

FileName: PipelineStream.java

// import statement
import java.util.*;

public class PipelineStream
{
// main method
public static void main(String argvs[]) 
{
// input list
List<Integer> nums = Arrays.asList(11, 12, 13, 14, 15);

int total = nums.stream().filter(y -> y % 2 != 0).map(y -> y * 2).reduce(0, Integer::sum);

System.out.println("The sum of twice of odd numbers in the input list is: " + total); 

}
}

Output:

The sum of twice of odd numbers in the input list is: 78

Lazy Evaluation

Lazy evaluation also known as the call-by-need evaluation is the evaluation strategy, in which the evaluation of strategies is delayed unless its value is not required. All operations that are intermediate are executed on the stream if a terminal operation is called on it. In Java stream, lazy evaluation is one of the main features that permits the significant optimizations.

FileName: LazyEvaluation.java

// Import statements for Stream and Collectors
import java.util.stream.Stream;
import java.util.stream.Collectors;  

public class LazyEvaluation 
{
// main method
public static void main(String[] argvs) 
{
    Stream<Integer> strm = Stream.of(2, 4, 5, 9, 15)
            .filter(y -> y % 2 == 1) // filtering the odd numbers
            .peek(y -> System.out.println("Filter Done: " + y)); // displaying the message

    System.out.println("Result is: ");
    System.out.println(strm.collect(Collectors.toList())); // last print statement
}
}

Output:

Result is: 
Filter Done: 5
Filter Done: 9
Filter Done: 15
[5, 9, 15]

Explanation: It is general known fact that, the first statement inside the main method executed first, and then the second statement, and after that the third statement, and so on. Going by this concept, the output should be:

Filter Done: 5
Filter Done: 9
Filter Done: 15
Result is: 
[5, 9, 15]

However, it is not the case. The print statement that contains "Result is: " gets executed first, and the filter() and peek() methods are not executed at all. These methods get executed when the terminal operation collect() is executed in the last print statement.

Points to Remember About Java Streams

The following are some important points that a user must know.

Streams are sequence of elements that can be processed or modified using the pipeline of operations. They are not data structures.
Streams provide support to two operations types: one is intermediate and other is terminal. Intermediate operations filter or transform the stream, while terminal operations produce a side effect or result.
The way streams are designed, make them lazy, which means processing of elements happens when there is a demand of it.
Java Streams are not apt for every scenario. In some of the cases, traditional iteration with the help of loops may be more efficient and appropriate.

Next TopicXOR Operation on Integers in Java

← prev next →