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
– 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.
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.
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
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
An intermediate operation is an operation that always returns a new stream.
– 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)
– 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)
-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
A terminal operation is an operation that returns non-stream values such as Optional, object, collection and more.
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
-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}
-Loop through each element of the given stream. It is a new feature provided in Java 8.
Syntax
forEach(Consumer<? super T> action)
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.
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.
This post was last modified on September 20, 2020