Concept of Stream in Java

What are Stream in Java?

Java Streams offer a potent and efficient method for handling element sequences, like collections. The Stream API, was first released in Java 8, enables programmers to express intricate data transformations and manipulations using a functional programming approach.

In Java, a stream is a collection of components from a source that facilitates aggregate operations rather than a data structure in and of itself. Both parallel and sequential execution are possible for these operations. Because streams are functional by nature, developers can express sophisticated data transformations using fewer lines of code.

Creating Streams

In Java, streams can be created in multiple ways. I/O channels, arrays, and collections are a few examples of common sources. Here are a few instances:

1. From a Collection:

List<String> myList = Arrays.asList("apple", "banana", "orange");
Stream<String> streamFromList = myList.stream();

2. From an Array:

int[] myArray = {1, 2, 3, 4, 5};
IntStream streamFromArray = Arrays.stream(myArray);

3. Using Stream.of():

Intermediate and Terminal Operations

Both intermediate and terminal operations are supported by the intermediate and terminal operations streams.

1. Intermediate Operations

These processes change one stream into another. Map, sorted, and filter are a few examples of intermediate operations. Because they wait to be executed until a terminal operation is called, intermediate operations are lazy.

List<String> filteredList = myList.stream().filter(s -> s.startsWith("a")) .map(String::toUpperCase).collect(Collectors.toList());

2. Terminal Operations

These actions result in an outcome or an unintended consequence. ForEach, collect, reduce, and count are a few examples of terminal operations. The processing of the stream is started by terminal operations.

Parallel Streams

For huge datasets, Java Streams can be handled in parallel to improve performance. To do this, use a stream and the parallel() method.

Use Cases

Streams are very helpful for operations like data reduction, filtering, and mapping. Finding the total of all even numbers in a list, for instance:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.stream()
                 .filter(n -> n % 2 == 0)
                 .mapToInt(Integer::intValue)
                 .sum();

Managing Exceptions in Streams

Managing exceptions within streams can present some challenges. The lambda expression needs to catch or declare checked exceptions.

List<String> myList = Arrays.asList("a", "b", "c");
myList.stream()
       .map(s -> {
           try {
               return riskyOperation(s);
           } catch (Exception e) {
               throw new RuntimeException(e);
           }
       })
       .forEach(System.out::println);

Reducing

A stream's elements can be combined into a single outcome by using the reduced operation in streams. It can be used to carry out operations like calculating the product or sum of items and just requires a binary operator.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, Integer::sum);
// Result: 15

Grouping and Partitioning

Streams offer strong partitioning and grouping capabilities. Methods like groupingBy() and partitioningBy(), dividing components according to a predicate or grouping them according to a classifier, are available in the Collectors class.

List<String> myList = Arrays.asList("apple", "banana", "orange", "grape", "kiwi");
Map<Integer, List<String>> groupedByLength = myList.stream().collect(Collectors.groupingBy(String::length));
// Result: {5=[apple, grape], 6=[banana], 7=[orange], 4=[kiwi]}

Using flatMap() for mapping

A stream of collections can be flattened into a single stream by using the flatMap() method. It is especially helpful for managing nested collections.

List<List<Integer>> listOfLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);
List<Integer> flattenedList = listOfLists.stream()
                                       .flatMap(List::stream)
                                       .collect(Collectors.toList());

Lazy Evaluation

Lazy evaluation is a fundamental component of Java Streams. Until a terminal operation is called, intermediate operations are not carried out. Accordingly, streams can maximize efficiency by processing only the data required to generate the desired outcome.

List<String> myList = Arrays.asList("apple", "banana", "orange", "grape", "kiwi");
Stream<String> filteredStream = myList.stream()
                                     .filter(s -> {
                                         System.out.println("Filtering: " + s);
                                         return s.length() > 5;
                                     });
List<String> resultList = filteredStream.collect(Collectors.toList());

UpdatedDemo.java

import java.util.*;
import java.util.stream.*;
class UpdatedDemo {
    public static void main(String args[]) {
        // Create a list of integers
        List<Integer> numbersList = Arrays.asList(12, 23, 24, 15);
        List<Integer> squaredNumbersList =
                numbersList.stream()
                        .map(x -> x * x)
                        .collect(Collectors.toList());
        List<String> wordsList = Arrays.asList(
                "Reflection", "Collection", "Stream");
        // Demonstration of filter method
        List<String> filteredWordsList =
                wordsList.stream()
                        .filter(s -> s.startsWith("S"))
                        .collect(Collectors.toList());
        System.out.println(filteredWordsList);
        // Demonstration of sorted method
        List<String> sortedWordsList =
                wordsList.stream()
                        .sorted()
                        .collect(Collectors.toList());
        System.out.println(sortedWordsList);
        // Create a list of integers
        List<Integer> moreNumbersList =
                Arrays.asList(2, 3, 4, 5, 2);
        // Collect method returns a set
        Set<Integer> squaredNumbersSet =
                moreNumbersList.stream()
                        .map(x -> x * x)
                        .collect(Collectors.toSet());
        System.out.println(squaredNumbersSet);
        // Demonstration of forEach method
        numbersList.stream()
                .map(x -> x * x)
                .forEach(y -> System.out.println(y));
        // Demonstration of reduce method
        int sumOfEvenNumbers =
                numbersList.stream()
                        .filter(x -> x % 2 == 0)
                        .reduce(0, (ans, i) -> ans + i);
        System.out.println(sumOfEvenNumbers);
    }
}

Output:

[Stream]
[Collection, Reflection, Stream]
[16, 4, 9, 25]
144
529
576
225
36

Conclusion

Java Streams offers a cutting-edge and practical method for managing data collections. Through the utilization of functional programming, developers can produce code that is terser and expressive. The readability and maintainability of code can be greatly enhanced by comprehending and utilizing Java Streams, regardless of the size of the datasets you are working with.

Next TopicConstraints in Java

← prev next →