Another Java 8 important feature, it can be defined as a pipeline through which a collection of objects and primitive data can be streamed through and a set of operations are performed over each object.

In other words, It is used to process a collection of objects. It streams over a sequence of objects from a source ( collection of objects or primitive types ), perform intermediate operations on each and every element of that source and provide the final outcome.
A stream can be accompanied by zero or more intermediate operations.

Points to remember:

– It converts the normal list to a stream
– It is used to process data using filter, map and other, the final output can be collected to form a list

– It doesn’t manipulate original data, instead creates a new stream
– It provides various stream operation such as map, filter and more
– An element in a stream is always traversed exactly once.
– It does the stream lazily as it doesn’t traverse until the terminal operation doesn’t get executed

-It forms a pipeline where intermediate operations and terminal operations are chained together

There are two ways in Collection interface to produce a Stream:

– stream() -> It returns a sequential stream
– parallelStream() ->  Returns a parallel stream. It utilizes the multiple cores of the computer by creating multiple threads to form sub-streams and assigns them given tasks which execute in parallel.

A stream can be split into two operations. An intermediate operation where all the manipulation is done and a terminal which produces the end result.

Stream Source or Create a Stream

A source might represent an array, collection and other. Another way is, to create a stream and do the further opertion on that particular stream.

Create Streams

• Stream.of

A static method that returns a squence of ordered stream.

Stream.of(val1,val2 .. ......)

Code Example :

public class CreateStreams {

    public static void main(String[] args) {
// Creating Stream of Characters
        Stream<Character> characterStream = Stream.of('P', 'R', 'O', 'G', 'R', 'A', 'M', 'M', 'E', 'R', 'B', 'A', 'Y');
// Now Printing it as a word
        characterStream.forEach(singleCharacter -> System.out.print(singleCharacter));
    }
}

Output:

PROGRAMMERBAY

One can also create Stream of array with Stream.of() method.

For example:

public class CreateStreams {

    public static void main(String[] args) {
        String[] stringArr = new String[]{"This", "is", "Example", "of", "Stream"};
        // Creating Stream of Array
        Stream<String> arrayStream = Stream.of(stringArr);
        arrayStream.forEach(singleString -> System.out.print(singleString + " "));
    }
}

Output:

This is Example of Stream

• List.stream()

In this, a list acts like stream and all the operations are done, just as normal stream.

Code example :

public class CreateStreams {

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("A");
        stringList.add("list");
        stringList.add("example");
        stringList.add("with");
        stringList.add("Stream");

        stringList.forEach(singleString -> System.out.print(singleString + " "));
    }
}

Output:

A list example with Stream

Intermediate Operations

An intermediate operation is an operation that always returns a new stream.

• Filter()

– It allows us to put conditional checks and filter out specific element or data from the source data in form of a new stream.
– It uses predicate as an argument which always returns a boolean type.

Syntax:

filter(Predicate<? super T> predicate)

• Map()

– It allows us to manipulate the data source or process the data and get the result from it.

– It maps each element to its corresponding result and provides a new stream.

– It accepts Function as an argument which processes a given input to provide the result.

Syntax:

map(Function<? super T,? extends R> mapper)

• Sorted

-It sorts a list of elements as per natural order.

-However, one can achieve custom behaviour using Comparator.

Code Example :

public class CreateStreams {

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(5);
        integerList.add(2);
        integerList.add(12);
        integerList.add(1);
        integerList.add(45);
        integerList.add(9);
        integerList.stream().sorted().forEach(System.out::println);
    }
}

Output:

1
2
5
9
12
45

Terminal Operations

A terminal operation is an operation that returns non-stream values such as Optional, object, collection and more.

• Reduce()

A reduce method performs a certain operation on each element of a given list and produces a single output value. In simple words, it reduces a list to a single output.

-It takes two arguments, first is identity and the second one is Accumulator.

Identity: It resembles the initial value of the reduction operation and acts as a default output if no data exist in the given list.

Accumulator: It is itself a function that takes two parameters, the first one is partial output and the second argument represents the next element of the list.

Code example :

public class CreateStreams {

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(5);
        integerList.add(5);
        integerList.add(15);
        Integer sum = integerList.stream().reduce(0,(initialVal, nextElm) -> initialVal + nextElm );
        System.out.println("Sum  : "+sum);
    }
}

Output :

Sum  : 25

• Collect 

-It is used to translate a stream into a list.

-It simply consolidates all the processed result and returns a list

Syntax:

collect(Collector<? super T,A,R> collector)

Collecting stream data as an array :

toArray() is used to get an array as output after performing intermediate operations.

Code example: 

public class CreateStreams {
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(5);
        integerList.add(10);
        integerList.add(12);
        integerList.add(15);
        integerList.add(21);
        integerList.add(24);
        Integer[] intArr = integerList.stream().filter(singleElement -> (singleElement % 5 == 0)).toArray(Integer[]::new);
        for (Integer element :
                intArr) {
            System.out.println("Multiples of 5 : " + element);
        }
    }
}

Output:

Multiples of 5 : 5
Multiples of 5 : 10
Multiples of 5 : 15

Collecting stream data as a list :

collect(Collectors.toList()) is used to get a list as output after performing intermediate operations.

Code example: 

public class CreateStreams {

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(5);
        integerList.add(10);
        integerList.add(12);
        integerList.add(15);
        integerList.add(21);
        integerList.add(24);
        List<Integer> intList = integerList.stream().filter(singleElement -> (singleElement % 5 == 0)).collect(Collectors.toList());
        for (Integer element :
                intList) {
            System.out.println("Multiples of 5 : " + element);
        }
    }
}

Collecting stream data as a Map:

collect(Collectors.toMap() is used to get a Map as output after performing intermediate operations.

Code example: 

public class CreateStreams {

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(5);
        integerList.add(10);
        integerList.add(12);
        integerList.add(15);
        integerList.add(21);
        integerList.add(24);
        Map<Integer,Integer> intMap = integerList.stream().filter(singleElement -> (singleElement % 5 == 0)).collect(Collectors.toMap(key -> key / 5 , value -> value));
        System.out.println("Map " + intMap);
    }
}

Output:

Map {1=5, 2=10, 3=15}

• forEach

-Loop through each element of the given stream. It is a new feature provided in Java 8.

Syntax

forEach(Consumer<? super T> action)

Filter and forEach program example:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList(Arrays.asList(5,10,50,15,30,40));

        list.stream().filter(singleEelement -> (singleEelement > 30)).forEach(element -> System.out.println("All value greater than 30 :- "+element));
    }
}

Output:

All value greater than 30 :-50
All value greater than 30 :-40

Explanation:

Above code,  filter method is creating a stream in which only values that are greater than 30 is present, then after, simply printing it over the screen using forEach() method.

Map and Collect program example

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList(Arrays.asList(5,10,50,15,30,40));

      List newList =  list.stream().map(singleEelement -> singleEelement+5).collect(Collectors.toList());

    newList.forEach(element -> System.out.println(element));
    }
}

Output:

10
15
55
20
35
45

Explanation:

Above code,  map method is creating a stream in which each element is incremented by 5 are present, then after, simply converting it to list.