What is Java Parallel Streams?

24 Dec, 2021
Java Parallel Streams is a feature of Java 8 and higher, meant for utilizing multiple cores of the processor. Normally any java code has one stream of processing, where it is executed sequentially. Whereas by using parallel streams, we can divide the code into multiple streams that are executed in parallel on separate cores and the final result is the combination of the individual outcomes. The order of execution, however, is not under our control.
Therefore, it is advisable to use parallel streams in cases where no matter what is the order of execution, the result is unaffected and the state of one element does not affect the other as well as the source of the data also remains unaffected.
Parallel Streams were introduced to increase the performance of a program, but opting for parallel streams isn’t always the best choice. There are certain instances in which we need the code to be executed in a certain order and in these cases, we better use sequential streams to perform our task at the cost of performance. The performance difference between the two kinds of streams is only of concern for large-scale programs or complex projects. For small-scale programs, it may not even be noticeable. Basically, you should consider using Parallel Streams when the sequential stream behaves poorly.
There are two ways we can create which are listed below and described later as follows:
Using parallel() method on a streamUsing parallelStream() on a Collection 
Using parallel() method on a stream
Using parallelStream() on a Collection 
Method 1: Using parallel() method on a stream
The parallel() method of the BaseStream interface returns an equivalent parallel stream. Let us explain how it would work with the help of an example.
In the code given below, we create a file object which points to a pre-existent ‘txt’ file in the system. Then we create a Stream that reads from the text file one line at a time. Then we use the parallel() method to print the read file on the console. The order of execution is different for each run, you can observe this in the output. The two outputs given below have different orders of execution.
Example 
Java
// Java Program to Illustrate Parallel Streams// Using parallel() method on a Stream  // Importing required classesimport java.io.File;import java.io.IOException;import java.nio.file.Files;import java.util.stream.Stream;  // Main class// ParallelStreamTestpublic class GFG {      // Main driver method    public static void main(String[] args) throws IOException {          // Creating a File object        File fileName = new File("M:\\Documents\\Textfile.txt");          // Create a Stream of string type        // using the lines() method to        // read one line at a time from the text file        Stream<String> text = Files.lines(fileName.toPath());          // Creating parallel streams using parallel() method        // later using forEach() to print on console        text.parallel().forEach(System.out::println);          // Closing the Stream        // using close() method        text.close();    }}
Output: 
1A
Output 1
 
1B
Output 2
Method 2: Using parallelStream() on a Collection
The parallelStream() method of the Collection interface returns a possible parallel stream with the collection as the source. Let us explain the working with the help of an example.
Implementation:
In the code given below, we are again using parallel streams but here we are using a List to read from the text file. Therefore, we need the parallelStream() method.
Example
Java
// Java Program to Illustrate Parallel Streams// using parallelStream() method on a Stream  // Importing required classesimport java.io.File;import java.io.IOException;import java.nio.file.Files;import java.util.*;  // Main class// ParallelStreamsTestpublic class GFG {      // Main driver method    public static void main(String[] args)        throws IOException    {          // Creating a File object        File fileName            = new File("M:\\Documents\\List_Textfile.txt");          // Reading the lines of the text file by        // create a List using readAllLines() method        List<String> text            = Files.readAllLines(fileName.toPath());          // Creating parallel streams by creating a List        //  using readAllLines() method        text.parallelStream().forEach(System.out::println);    }}
Output:
Output
ihsanalgul55
simmytarika5
Java Parallel-Streams
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.