Java 8 Stream Tutorial

Java 8 introduces Stream, which is a new abstract layer, and some new additional packages in Java 8 called java.util.stream. A Stream is a sequence of components that can be processed sequentially. These packages include classes, interfaces, and enum to allow functional-style operations on the elements.

The stream can be used by importing java.util.stream package. Stream API is used to process collections of objects. Streams are designed to be efficient and can support improving your program’s performance by allowing you to avoid unnecessary loops and iterations. Streams can be used for filtering, collecting, printing, and converting from one data structure to another, etc. 

This Java 8 Stream Tutorial will cover all the basic to advanced concepts of Java 8 stream like Java 8 filter and collect operations, and real-life examples of Java 8 streams.

Prerequisites for Java Stream

Before proceeding to Java 8, it’s recommended to have a basic knowledge of Java 8 and its important concepts such as lambda expression, Optional, method references, etc.

Note: 

• If we want to represent a group of objects as a single entity then we should go for collection.
• But if we want to process objects from the collection then we should go for streams.

If we want to use the concept of streams then stream() is the method to be used. Stream is available as an interface.

Syntax:

Stream s = c.stream();

In the above pre-tag, ‘c’ refers to the collection. So on the collection, we are calling the stream() method and at the same time, we are storing it as the Stream object. Henceforth, this way we are getting the Stream object.

Note: Streams are present in java’s utility package named java.util.stream

Let us now start with the basic components involved in streams. They as listed as follows:

• Sequence of Elements
• Source
• Aggregate Operations
• Pipelining
• Internal iteration

Features of Java Stream

• A stream is not a data structure instead it takes input from the Collections, Arrays, or I/O channels.
• Streams don’t change the original data structure, they only provide the result as per the pipelined methods.
• Each intermediate operation is lazily executed and returns a stream as a result, hence various intermediate operations can be pipelined. Terminal operations mark the end of the stream and return the result.

Before moving ahead in the concept consider an example in which we are having ArrayList of integers, and we suppose we apply a filter to get only even numbers from the object inserted.

How does Stream Work Internally?

In streams,

• To filter out from the objects we do have a function named filter()
• To impose a condition we do have a logic of predicate which is nothing but a functional interface. Here function interface can be replaced by a random expression. Hence, we can directly impose the condition check-in our predicate.
• To collect elements we will be using Collectors.toList() to collect all the required elements.
• Lastly, we will store these elements in a List and display the outputs on the console.

Example 

// Java Program to illustrate FILTER 
// & COLLECT Operations
import java.io.*;
import java.util.*;
import java.util.stream.*;

// Main class
public class GFG {

    // Main driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList object of integer type
        ArrayList<Integer> al = new ArrayList<Integer>();

        // Inserting elements to ArrayList class object
        // Custom input integer numbers
        al.add(2);
        al.add(6);
        al.add(9);
        al.add(4);
        al.add(20);

        // First lets print the collection
        System.out.println("Printing the collection : "
                           + al);

        // Printing new line for better output readability
        System.out.println();

        // Stream operations
        // 1. Getting the stream from this collection
        // 2. Filtering out only even elements
        // 3. Collecting the required elements to List
        List<Integer> ls
            = al.stream()
                  .filter(i -> i % 2 == 0)
                  .collect(Collectors.toList());

        // Print the collection after stream operation
        // as stored in List object
        System.out.println(
            "Printing the List after stream operation : "
            + ls);
    }
}

Printing the collection : [2, 6, 9, 4, 20]

Printing the List after stream operation : [2, 6, 4, 20]

Explanation of the above program: 

In our collection object, we were having elements entered using the add() operation. After processing the object in which they were stored through streams we impose a condition in the predicate of streams to get only even elements, we get elements in the object as per our requirement.  Hence, streams helped us this way in processing over-processed collection objects.

Various Core Operations Over Streams

There are broadly 3 types of operations that are carried over streams namely as follows as depicted from the image shown above:

1. Intermediate operations
2. Terminal operations
3. Short-circuit operations

Let us do discuss out intermediate operations here only in streams to a certain depth with the help of an example in order to figure out other operations via theoretical means. 

1. Intermediate Operations:

Intermediate operations transform a stream into another stream. Some common intermediate operations include:

1. filter(): Filters elements based on a specified condition.
2. map(): Transforms each element in a stream to another value.
3. sorted():  Sorts the elements of a stream.

All three of them are discussed below as they go hand in hand in nearly most of the scenarios and to provide better understanding by using them later by implementing in our clean Java programs below. As we already have studied in the above example of which we are trying to filter processed objects can be interpreted as filter() operation operated over streams.

2. Terminal Operations

Terminal Operations are the operations that on execution return a final result as an absolute value.

1. collect(): It is used to return the result of the intermediate operations performed on the stream.
2. forEach(): It iterates all the elements in a stream. 
3. reduce(): It is used to reduce the elements of a stream to a single value.

3. Short Circuit Operations

Short-circuit operations provide performance benefits by avoiding unnecessary computations when the desired result can be obtained early. They are particularly useful when working with large or infinite streams.

1. anyMatch(): it checks the stream if it satisfies the given condition. 
2. findFirst(): it checks the element that matches a given condition and stops processing when it finds it.

Note: They are lazy, meaning they are not executed until a terminal operation is invoked.

Later on from that processed filtered elements of objects, we are collecting the elements back to List using Collectors for which we have imported a specific package named java.util.stream with the help of Collectors.toList() method. This is referred to as collect() operation in streams so here again we won’t be taking an example to discuss them out separately. 

Example:

// Java program to illustrate Intermediate Operations
// in Streams

// Importing required classes
import java.io.*;
import java.util.*;
import java.util.stream.*;

// Main class
class Test {

    // Main driver method
    public static void main(String[] args)
    {

        // Creating an integer Arraylist to store marks
        ArrayList<Integer> marks = new ArrayList<Integer>();

        // These are marks of the students
        // Considering 5 students so input entries
        marks.add(30);
        marks.add(78);
        marks.add(26);
        marks.add(96);
        marks.add(79);

        // Printing the marks of the students before grace
        System.out.println(
            "Marks of students before grace : " + marks);

        // Now we want to grace marks by 6
        // using the streams to process over processing
        // collection

        // Using stream, we map every object and later
        // collect to List
        // and store them
        List<Integer> updatedMarks
            = marks.stream()
                  .map(i -> i + 6)
                  .collect(Collectors.toList());

        // Printing the marks of the students after grace
        System.out.println(
            "Marks of students  after grace : "
            + updatedMarks);
    }
}

Marks of students before grace : [30, 78, 26, 96, 79]
Marks of students  after grace : [36, 84, 32, 102, 85]

Note: For every object if there is urgency to do some operations be it square, double or any other than only we need to use map() function  operation else try to use filter() function operation. 

Lazy Evaluation

Lazy Evaluation is the concept in Java Streams where computation on the source data is only performed when the terminal operation is initiated, and source elements are consumed only as needed. It is called lazy because intermediate operations are not evaluated unless a terminal operation is invoked.

Now geeks you are well aware of ‘why’ streams were introduced, but you should be wondering ‘where’ to use them. The answer is very simple as we do use them too often in our day-to-day life. Hence, the geek in simpler words we say directly lands p on wherever the concept of the collection is applicable, stream concept can be applied there. 

Java Stream: Real-life Examples

Example 1:

In general, daily world, whenever the data is fetched from the database, it is more likely we will be using collection so there stream concept is must apply to deal with processed data.

Now we will be discussing real-time examples to interrelate streams in our life. Here we will be taking the most widely used namely as follows:

1. Streams in a Grocery store
2. Streams in mobile networking

1. Streams in a Grocery store 

The above pictorial image has been provided is implemented in streams which are as follows: 

List<Integer> transactionsIds = 
    transactions.stream()
                .filter(t -> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

2. Streams in mobile networking 

Similarly, we can go for another widely used concept which is our dealing with our mobile numbers. Here we will not be proposing listings, simply will be demonstrating how the stream concept is invoked in mobile networking by various service providers across the globe.

Collection can hold any number of object so let ‘mobileNumber’ be a collection and let it be holding various mobile numbers say it be holding 100+ numbers as objects. Suppose now the only carrier named ‘Airtel’ whom with which we are supposed to send a message if there is any migration between states in a country. So here streams concept is applied as if while dealing with all mobile numbers we will look out for this carrier using the filter() method operation of streams. In this way, we are able to deliver the messages without looking out for all mobile numbers and then delivering the message which senses impractical if done so as by now we are already too late to deliver. In this way these intermediate operations namely filter(), collect(), map() help out in the real world. Processing becomes super simpler which is the necessity of today’s digital world.

Hope by now you the users come to realize the power of streams in Java as if we have to do the same task we do need to map corresponding to every object, increasing in code length, and decreasing the optimality of our code. With the usage of streams, we are able to in a single line irrespective of elements contained in the object as with the concept of streams we are dealing with the object itself.

Note: filter, sorted, and map, which can be connected together to form a pipeline.

What is a Pipeline?

A Stream Pipeline is a concept of chaining operations together Terminal Operations and Intermediate Operations. A Pipeline contains a stream source, which is further followed by zero or more intermediate operations, and a terminal operation.

Java Stream Operations

Method Types and Pipelines

Methods are of two types in Stream as mentioned below:

1. Terminal Operations
2. Intermediate Operations

Terminal Operations

These are the operations that after consumed can’t further be used. There are few operations mentioned below:

1. forEach

forEach performs an action for each element of the stream. Stream forEach is a terminal operation.

Syntax

void forEach(Consumer<? super T> action)

2. toArray

Stream toArray() returns an array containing the elements of this stream. After the terminal operation is performed, the stream pipeline is considered consumed, and can no longer be used.

Syntax

Object[] toArray()

3. min and max

min and max return the min and max elements from the stream.

Syntax

Optional<T> min(Comparator<? super T> comparator)
Optional<T> max(Comparator<? super T> comparator)

Where, Optional is a container object which may or may not contain a non-null value, and T is the type of object that may be compared by this comparator.

Intermediate Operations

It returns a new stream that can be further processed. There are certain operations mentioned below:

1. filter

Stream filter returns a stream consisting of the elements of this stream that match the given predicate.

Syntax

Stream<T> filter(Predicate<? super T> predicate)

2. distinct

distinct() returns a stream consisting of distinct elements in a stream. distinct() is the method of Stream interface.

Syntax

Stream<T> distinct()

Where Stream is an interface and the function returns a stream consisting of distinct elements.

3. Sorted

Stream sorted() returns a stream consisting of the elements of this stream, sorted according to natural order. For ordered streams, the sort method is stable but for unordered streams, no stability is guaranteed.

Syntax

Stream<T> sorted()

where Stream is an interface and T is the type of stream elements.

Comparison-Based Stream Operations

Comparison Based Stream Operations are the used for comparing, sorting, and ordering elements within a stream. There are certain examples of Comparison Based Stream Operations mentioned below:

1. Sorted
2. min and max
3. distinct

Java Stream Specializations

As there are primitive data types or specializations like int, long and double. Similarly, streams have IntStream, LongStream, and DoubleStream. These are convenient for making performing transactions with numerical primitives.

1. Specialized Operations

Specialized streams provide additional operations as compared to the standard Stream – which are quite convenient when dealing with numbers.

2. Reduction Operations

Reduce Operation applies a binary operator, it takes a sequence of input elements and combines them to a single summary result. It is all done where first argument to the operator is the return value of the previous application and second argument is the current stream element.

Parallel Streams

Parallel Streams are the type of streams that can perform operations concurrently on multiple threads. These Streams are meant to make use of multiple processors or cores available to speed us the processing speed. There are two methods to create parallel streams are mentioned below:

1. Using the parallel() method on a stream
2. Using parallelStream() on a Collection

To know more about Parallel Streams refer to this link.

Infinite Streams

Infinite Streams are the type of Streams that can produce unbounded(Infnite) number of elements. These Streams are useful when you need to work with the data sources that are not finite.

Java Stream: File Operation

In this section, we see how to utilize Java stream in file I/O operation. 

1. File Read Operation

Let’s understand file read operation through the given example

// Java Program to demonstrate
// File Read Operation
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class GFG {
    // Method to filter strings of a given length and
    // convert them to uppercase
    private static List<String>
    filterAndConvertToUpper(Stream<String> stream,
                            int length)
    {
        return stream.filter(s -> s.length() == length)
            .map(String::toUpperCase)
            .collect(Collectors.toList());
    }

    public static void main(String[] args)
    {
        // Replace with the
        // actual file path
        String fileName = "path/to/your/file.txt";

        // Step 1: Create a Stream of lines from the
        // file
        try (Stream<String> lines
             = Files.lines(Paths.get(fileName))) {

            List<String> filteredStrings
                = filterAndConvertToUpper(lines, 5);
            System.out.println(
                "Filtered strings with length 5 (converted to uppercase): "
                + filteredStrings);
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Input:

Geeks
gfg
geeks
geeksforgeeks
Coder
Guys

Output:

Filtered strings with length 5 (converted to uppercase): [GEEKS, GEEKS, CODER]

2. File Write Operation

Let’s understand file write operation through the given example

// Java Program to demonstrate
// File Write Operation
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

// Driver Class
class GFG {
    // main function
    public static void main(String[] args)
    {
        String[] words
            = { "Geeks", "for", "Geeks", "Hello", "World" };

        // Replace with the
        // actual file path

        String fileName = "path/to/your/file.txt";

        // Step 1: Create a PrintWriter to write to the
        // file
        try (PrintWriter pw
             = new PrintWriter(Files.newBufferedWriter(
                 Paths.get(fileName)))) {

            // Step 2: Use Stream to write each word to the
            // file
            Stream.of(words).forEach(pw::println);

            // Step 3: Print success message to the console
            System.out.println(
                "Words written to the file successfully.");
        }
        catch (IOException e) {
            // Step 4: Handle any IO exception that occurs
            // during the file writing process
            e.printStackTrace();
        }
    }
}

Output:

Words written to the file successfully.

Java Streams Improvements in Java 9

As we know, Java 8 introduced a Java stream to the world which provided a powerful way to process collections of data. However, the following version of the language also contributed to the feature. Thereafter, some improvements and features were added to the Java stream in JAVA 9. In this section, we will provide an overview of the advancements introduced by Java 9 to the Streams API like takeWhile, dropWhile, iterate, ofNullable, etc.

Conclusion

Java Streams offer a powerful way to handle data in Java. They allow developers to write more readable and concise code for processing collections. By using Java Streams, you can easily filter, map, and reduce data with simple and expressive methods. This not only makes your code easier to maintain but also helps improve performance by taking advantage of parallel processing. If you’re looking to make your data operations more efficient and straightforward, learning Java Streams is definitely worth the effort.

Java 8 Stream – FAQs

1. How to learn streams in Java 8?

To learn java streams effectivily you need to get you theory concepets as well as practical skills strong. for that first you need to make your concepts strong then make it in pratice.

1. Grasp the fundamental concept of streams. 
   • What are streams?
   • Why are they useful?
   • How do they work?
2. Familiarize yourself with creating streams from diverse sources. 
   • How can you create a stream from an array, a collection, or a file?
3. Dive into intermediate operations. 
   • What are intermediate operations?
   • How do they transform data?
4. Understand terminal operations. 
   • What are terminal operations?
   • How do they produce final results or trigger actions on the stream?
5. Embrace the concept of lazy evaluation. 
   • How does lazy evaluation work? How does it optimize resource usage?
6. Practice chaining operations to create intricate data pipelines. 
   • How can you chain multiple operations together to create complex data pipelines?
7. Explore parallel processing. 
   • How can you use parallel processing to improve the performance of your streams?
8. Apply streams to real-world scenarios. 
   • Find situations where streams can simplify code and improve efficiency.
9. Utilize online resources, tutorials, and exercises.
10. Consider in-depth tutorials. If you want a comprehensive learning experience, consider taking an in-depth tutorial on streams.

2. Why we use stream in Java 8?

Java streams offer a range of functionalities that significantly enhance their importance.

1. Efficient Data Processing: They don’t store the data themselves, but instead act as a way to process data from various DS.
2. Functional and Non-Destructive: Streams follow a functional programming approach.
3. Lazy Evaluation: which means they perform computations only when needed
4. Single Pass Processing: The elements in a stream are processed only once during its lifetime

3. What is the best practice of Java streams?

Java Stream API is a powerful and flexible tool that can significantly simplify code for data processing tasks and here are some best pratices for using java streams.

1. Use primitive streams for better performance
2. Avoid nesting streams
3. use stream with immutable objects
4. Use filter() before map() to avoid unnecessary processing
5. Prefer method references over lambda expressions
6. Use distinct() to remove duplicates
7. Use sorted() with caution
8. Use lazy evaluation for better performance

solankimayank

Follow

Improve