Java 8 introduced a revolutionary feature called Streams, which allows developers to process collections in a more declarative and functional style. This new addition simplifies complex operations, enhances readability, and improves performance, especially when combined with parallel processing. In this article, we will explore how Java Streams work, their core concepts, and practical examples that demonstrate their usage.
What are Streams in Java 8?
Before the introduction of Streams, processing collections in Java was done using traditional loops and iterators. While this approach worked fine, it was often verbose, and the logic could get tangled. With Java 8, the Stream API brought in functional programming principles, allowing developers to work with collections in a more concise and powerful way.
A Stream represents a sequence of elements that can be processed in parallel or sequentially. Streams support a variety of operations, such as filtering, mapping, reducing, and collecting. These operations can be chained together to form a powerful data pipeline for processing collections.
Stream Characteristics
- Non-Storage: Streams do not store data. They convey elements from a data structure, such as a collection, array, or I/O channel.
- Functional: Operations on Streams are expressed using lambda expressions or method references.
- Laziness: Intermediate operations are lazy, meaning they are not executed until a terminal operation is invoked. This improves performance by avoiding unnecessary computations.
- Composable: Streams allow operations to be chained together in a fluent manner, improving readability and maintainability.
Basic Components of a Stream
A Stream in Java can be broken down into three main components:
- Source: The source is the data structure or collection from which the Stream originates. Examples include collections, arrays, or I/O channels.
- Intermediate Operations: These operations return a new Stream and allow you to modify the data as it flows through the pipeline. They are lazy and only get executed when a terminal operation is invoked. Examples:
filter(),map(),sorted(). - Terminal Operations: These operations consume the Stream and produce a result or a side-effect. Examples:
collect(),forEach(),reduce().
Basic Operations in Java Streams
Let’s explore some basic operations available in the Stream API, which you can use to manipulate collections efficiently.
1. Creating Streams
There are multiple ways to create Streams in Java 8. Let’s consider a few:
// From a Collection
List list = Arrays.asList("Apple", "Banana", "Orange");
Stream streamFromList = list.stream();
// From an Array
String[] array = {"Java", "Python", "C++"};
Stream streamFromArray = Arrays.stream(array);
// Using Stream.of() for single elements
Stream streamFromElements = Stream.of("A", "B", "C");
2. Intermediate Operations
Intermediate operations transform the elements of a Stream. They are lazy and do not execute until a terminal operation is invoked.
- Filter – Filters elements based on a given condition (predicate).
- Map – Transforms each element by applying a function.
- Sorted – Sorts the elements in a Stream.
Example 1: Using filter() and map()
List names = Arrays.asList("Alice", "Bob", "Charlie", "David");
// Filter and map operations
List result = names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(result); // Output: [ALICE]
Example 2: Using sorted()
List numbers = Arrays.asList(5, 3, 7, 1, 9);
// Sorting the list
List sortedNumbers = numbers.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(sortedNumbers); // Output: [1, 3, 5, 7, 9]
3. Terminal Operations
Terminal operations are those that produce a result or a side-effect and mark the end of the Stream pipeline.
- Collect – Collects the elements of the Stream into a container, such as a List, Set, or Map.
- ForEach – Performs an action for each element of the Stream.
- Reduce – Reduces the elements of the Stream into a single value by repeatedly applying a binary operator.
Example 1: Using collect()
List numbers = Arrays.asList(1, 2, 3, 4, 5);
// Collecting the elements into a List
List result = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(result); // Output: [2, 4]
Example 2: Using forEach()
List fruits = Arrays.asList("Apple", "Banana", "Cherry");
// Printing each element
fruits.stream().forEach(System.out::println);
Example 3: Using reduce()
List numbers = Arrays.asList(1, 2, 3, 4);
// Summing the elements using reduce
int sum = numbers.stream()
.reduce(0, Integer::sum);
System.out.println(sum); // Output: 10
Advanced Stream Operations
1. Parallel Streams
Java Streams support parallelism, which allows for faster processing of large datasets by utilizing multiple threads. You can convert a Stream into a parallel Stream by invoking the parallel() method.
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Using parallelStream()
long count = numbers.parallelStream()
.filter(n -> n % 2 == 0)
.count();
System.out.println(count); // Output: 5
2. Grouping and Partitioning
Java 8 introduced powerful grouping and partitioning operations for categorizing elements in a Stream.
- groupingBy() – Groups elements based on a classifier function.
- partitioningBy() – Partitions elements into two groups based on a predicate.
Example 1: Grouping by length
List words = Arrays.asList("Apple", "Banana", "Cherry", "Avocado");
Map> groupedByLength = words.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength); // Output: {5=[Apple], 6=[Banana], 7=[Avocado], 6=[Cherry]}
Example 2: Partitioning by length
List words = Arrays.asList("Apple", "Banana", "Cherry", "Avocado");
Map> partitionedByLength = words.stream()
.collect(Collectors.partitioningBy(word -> word.length() > 5));
System.out.println(partitionedByLength); // Output: {false=[Apple, Cherry], true=[Banana, Avocado]}
Best Practices for Using Java Streams
- Prefer Parallel Streams when the dataset is large and can benefit from multi-core processing.
- Avoid side-effects in Stream operations to preserve immutability and enhance readability.
- Prefer method references over lambda expressions when possible to improve code clarity.
- Ensure that Streams are closed when working with I/O resources to avoid resource leaks.
