Introduction to the Stream API
The Stream API is a feature introduced in Java 8 that provides a fluent and functional approach to processing collections of data. It allows you to write code that is concise, readable, and easily parallelizable. Streams are designed to be lazy and can handle large amounts of data efficiently without requiring intermediate data structures.
A Stream is an ordered sequence of elements that can be processed in parallel or sequential order. Each element in the Stream is processed once and only once, and the Stream is closed when the processing is finished. You can create a Stream from any collection or array using the stream() method or from individual elements using the of() method.
Here’s an example of how to create a Stream from a list of integers:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); Stream<Integer> stream = numbers.stream();
Once you have a Stream, you can use a variety of intermediate and terminal operations to process the elements in the Stream.
Intermediate Operations
Intermediate operations are operations that transform or filter the elements in the Stream. They are typically used to build a processing pipeline that is composed of a series of operations that process the data in a specific order.
Here are some of the most commonly used intermediate operations:
Filter
The filter operation takes a predicate that tests each element in the Stream and returns a new Stream that contains only the elements that pass the predicate.
Here’s an example of how to use the filter operation to extract all even numbers from a Stream of integers:
Stream<Integer> stream = numbers.stream(); Stream<Integer> evenNumbers = stream.filter(n -> n % 2 == 0);
Map
The map operation takes a function that transforms each element in the Stream and returns a new Stream that contains the transformed elements.
Here’s an example of how to use the map operation to convert a Stream of strings to a Stream of their lengths:
Stream<String> stream = Stream.of("Java", "is", "awesome");
Stream<Integer> lengths = stream.map(String::length);
FlatMap
The flatMap operation takes a function that returns a Stream for each element in the Stream and returns a new Stream that contains all of the elements from all of the Streams.
Here’s an example of how to use the flatMap operation to flatten a Stream of lists:
Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4)); Stream<Integer> flattened = stream.flatMap(List::stream);
Distinct
The distinct operation returns a new Stream that contains only the unique elements from the original Stream.
Here’s an example of how to use the distinct operation to extract the unique elements from a Stream of integers:
Stream<Integer> stream = numbers.stream(); Stream<Integer> uniqueNumbers = stream.distinct();
Sorted
The sorted operation returns a new Stream that contains the elements from the original Stream sorted in natural order or according to a specified Comparator.
Here’s an example of how to use the sorted operation to sort a Stream of strings in alphabetical order:
Stream<String> stream = Stream.of("Java", "is", "awesome");
Stream<String> sorted = stream.sorted();
Peek
The peek operation takes a Consumer that is executed for each element in the Stream and returns a new Stream that contains the original elements. It is useful for debugging or logging the elements as they pass through the processing pipeline.
Here’s an example of how to use the peek operation to print each element in a Stream of strings:
Stream<String> stream = Stream.of("Java", "is", "awesome");
Stream<String> peeked = stream.peek(System.out::println);
Terminal Operations
Terminal operations are operations that terminate the processing pipeline and return a result. They are typically used to collect the elements in the Stream into a data structure or to perform a final computation on the elements.
Here are some of the most commonly used terminal operations:
Count
The count operation returns the number of elements in the Stream as a long value.
Here’s an example of how to use the count operation to count the elements in a Stream of integers:
Stream<Integer> stream = numbers.stream(); long count = stream.count();
Collect
The collect operation takes a Collector that accumulates the elements in the Stream into a collection or other data structure.
Here’s an example of how to use the collect operation to collect the even numbers in a Stream of integers into a list:
Stream<Integer> stream = numbers.stream(); List<Integer> evenNumbers = stream.filter(n -> n % 2 == 0).collect(Collectors.toList());
Reduce
The reduce operation takes a BinaryOperator that combines the elements in the Stream and returns a result. It can be used to perform a final computation on the elements in the Stream, such as finding the sum, maximum, or minimum value.
Here’s an example of how to use the reduce operation to find the sum of the elements in a Stream of integers:
Stream<Integer> stream = numbers.stream(); int sum = stream.reduce(0, Integer::sum);
Conclusion
The Stream API is a powerful tool that allows you to write expressive and concise code for processing collections of data in Java. With a variety of intermediate and terminal operations, you can build complex processing pipelines that efficiently handle large amounts of data. I hope this guide has provided a helpful introduction to the Stream API and some of its most commonly used operations.