Java 8 introduced several important new features, one of which is the Stream API. The Stream API is a powerful tool for processing collections of data. It provides a concise, efficient, and easily parallelizable way to handle data streams, significantly sipmlifying the complexity of writing code. This article will delve into the basic concepts, usage, and practical applicasions of the Java 8 Stream API.

Note: The code examples provided below can be directly run in a main method to visually experience the power of streams.

1. What is the Stream API?

1.1 Basic Concepts

The Stream API is a new feature in Java 8. It is not a data structure but an abstraction for data computation. A Stream represents a sequence of data elements supporting sequential and parallel aggregate operations. Inspired by functional programming, streams allow operations such as filtering, mapping, and reducing on data.

1.2 Differences Between Streams and Traditional Collections

Tradisional collection frameworks (such as List, Set) primarily focus on data storage and access, while Streams focus on the process of data computation. Collections are static storages of data, whereas Streams are dynamic views of data that perform computations through a pipeline of intermediate and terminal operations.

2. Basic Stream Operations

2.1 Creating Streams

Streams can be created in various ways, including:

• From a collection
• From an array
• Using factory methods (e.g., Stream.of)
• Generating infinite streams

2.1.1 Creating a Stream from a Collection

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

2.1.2 Creating a Stream from an Array

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

2.1.3 Using Factory Methods

Stream<String> stream = Stream.of("a", "b", "c");

2.1.4 Generating Infinite Streams

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);

2.2 Intermediate Operations

Intermediate operations transform a stream into another stream. They are lazy, meaning they do not execute until a terminal operation is invoked. Common intermediate operations include filter, map, flatMap, distinct, sorted, and peek.

2.2.1 filter

The filter method selects elements that satisfy a given predicate.

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().filter(s -> s.startsWith("a"));

2.24.2 map

The map method transforms each element using a given function.

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().map(String::toUpperCase);

2.2.3 flatMap

The flatMap method flattens nested streams into a single stream.

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
Stream<String> flatStream = listOfLists.stream().flatMap(List::stream);

2.3 Terminal Operations

Terminal operations produce a result or a side effect. Once a terminal operation is executed, the stream is considered consumed and can no longer be used.

2.3.1 forEach

The forEach method performs an action for each element of the stream.

list.stream().forEach(System.out::println);

2.3.2 collect

The collect method accumulates elements into a collection or other data structure.

List<String> result = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());

2.3.3 reduce

The reduce method performs a reduction on the elements using a binary operator.

Optional<Integer> sum = numbers.stream().reduce((x, y) -> x + y);

3. Parallel Streams

One of the key advantages of the Stream API is the ease of parallel processing. By calling parallelStream() instead of stream(), the operations can be executed concurrently to leverage multi-core processors.

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

4. Practical Examples

4.1 Finding All Strings Starting with 'a'

List<String> words = Arrays.asList("apple", "banana", "apricot", "cherry");
List<String> filtered = words.stream()
                              .filter(word -> word.startsWith("a"))
                              .collect(Collectors.toList());
// Result: [apple, apricot]

4.2 Converting Strings to Uppercase

List<String> words = Arrays.asList("hello", "world");
List<String> upper = words.stream()
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());
// Result: [HELLO, WORLD]

4.3 Summing Numbers

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

5. Conclusion

The Java 8 Stream API is a powerful feature that enables functional-style operations on collections. It improves code readability, reduces boilerplate, and simplifies parallel processing. By mastering its operations, you can write cleaner and more efficient Java code.