Codecrown
Java Streams API: Complete Guide to Functional Data Processing
The Java Streams API provides a powerful way to process collections and other data sources using a declarative programming style. Instead of manually controlling loops and temporary collections, streams allow developers to describe what should happen to the data.
This guide covers the core Stream operations, collectors, transformations, grouping, flattening, reduction, and practical performance considerations.
1. Understanding Java Streams
A Stream is a sequence of elements that supports functional-style operations such as filtering, mapping, sorting, and aggregation.
Streams do not store data themselves. They process data from sources such as List, Set, arrays, maps, or generated values.
Intermediate operations: Operations such as filter, map, sorted, and distinct transform a stream and are generally lazy.
Terminal operations: Operations such as collect, forEach, count, reduce, and anyMatch consume the stream and produce a result or side effect.
2. Creating Streams
Creating a Stream from a Collection
import java.util.List;
public class StreamCreationExample {
public static void main(String[] args) {
List<String> languages = List.of(
"Java",
"Python",
"Go",
"JavaScript"
);
languages.stream()
.forEach(System.out::println);
}
}Creating a Stream from Values
import java.util.stream.Stream;
public class StreamOfExample {
public static void main(String[] args) {
Stream.of("Java", "Python", "Go")
.forEach(System.out::println);
}
}3. Filtering Data with filter()
The filter operation keeps only elements that satisfy a given condition.
import java.util.List;
public class FilterExample {
public static void main(String[] args) {
List<Integer> prices = List.of(
50, 120, 75, 250, 90, 300
);
prices.stream()
.filter(price -> price >= 100)
.forEach(System.out::println);
}
}The lambda expression price -> price >= 100 acts as the filtering predicate.
4. Transforming Data with map()
The map operation transforms every element into another value.
import java.util.List;
import java.util.stream.Collectors;
public class MapExample {
public static void main(String[] args) {
List<String> names = List.of(
"alice",
"bob",
"charlie"
);
List<String> uppercaseNames = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(uppercaseNames);
}
}5. Combining filter() and map()
Stream operations can be chained into a pipeline where each intermediate operation processes the output of the previous stage.
import java.util.List;
public class StreamPipelineExample {
public static void main(String[] args) {
List<String> names = List.of(
"Alice",
"Bob",
"Andrew",
"Charlie",
"Amanda"
);
names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.forEach(System.out::println);
}
}This pipeline first selects names beginning with A and then converts the selected values to uppercase.
6. Sorting and Removing Duplicates
Streams provide sorted() for ordering elements and distinct() for removing duplicate values.
import java.util.List;
public class SortingExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(
5, 2, 8, 2, 1, 5, 9, 3
);
numbers.stream()
.distinct()
.sorted()
.forEach(System.out::println);
}
}7. Flattening Nested Data with flatMap()
flatMap is useful when each element produces another collection or stream and the result needs to be combined into a single stream.
import java.util.List;
public class FlatMapExample {
public static void main(String[] args) {
List<List<String>> teams = List.of(
List.of("Alice", "Bob"),
List.of("Charlie", "David"),
List.of("Eve", "Frank")
);
teams.stream()
.flatMap(List::stream)
.forEach(System.out::println);
}
}Without flatMap, the result would remain a stream of lists. flatMap combines the nested streams into one stream of individual elements.
8. Collecting Stream Results
The Collectors utility provides powerful terminal operations for converting stream results into lists, sets, maps, and other structures.
import java.util.List;
import java.util.stream.Collectors;
public class CollectExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(
10, 15, 20, 25, 30
);
List<Integer> result = numbers.stream()
.filter(number -> number > 15)
.collect(Collectors.toList());
System.out.println(result);
}
}In modern Java versions, toList() can also be used directly when a suitable unmodifiable result is acceptable.
9. Aggregating Values with reduce()
The reduce operation combines multiple stream elements into a single result.
import java.util.List;
public class ReduceExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(10, 20, 30, 40);
int sum = numbers.stream()
.reduce(0, Integer::sum);
System.out.println("Sum: " + sum);
}
}Reduction is useful for operations such as sums, products, minimum values, maximum values, and custom aggregation logic.
10. anyMatch(), allMatch(), and noneMatch()
Matching operations allow applications to test conditions without manually iterating through every element.
import java.util.List;
public class MatchingExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(2, 4, 6, 8, 10);
boolean hasLargeValue = numbers.stream()
.anyMatch(number -> number > 8);
boolean allEven = numbers.stream()
.allMatch(number -> number % 2 == 0);
boolean noneNegative = numbers.stream()
.noneMatch(number -> number < 0);
System.out.println("Has large value: " + hasLargeValue);
System.out.println("All even: " + allEven);
System.out.println("None negative: " + noneNegative);
}
}11. Grouping Data with groupingBy()
Collectors.groupingBy() creates groups based on a classification function. It is especially useful for reporting and aggregation.
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
record Employee(String name, String department) {}
public class GroupingExample {
public static void main(String[] args) {
List<Employee> employees = List.of(
new Employee("Alice", "Engineering"),
new Employee("Bob", "Sales"),
new Employee("Charlie", "Engineering"),
new Employee("David", "Sales")
);
Map<String, List<Employee>> grouped =
employees.stream()
.collect(Collectors.groupingBy(
Employee::department
));
grouped.forEach((department, members) ->
System.out.println(department + " -> " + members)
);
}
}12. Partitioning Data
partitioningBy() divides elements into two groups based on whether a predicate evaluates to true or false.
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class PartitioningExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(
1, 2, 3, 4, 5, 6, 7, 8
);
Map<Boolean, List<Integer>> partitioned =
numbers.stream()
.collect(Collectors.partitioningBy(
number -> number % 2 == 0
));
System.out.println("Even: " + partitioned.get(true));
System.out.println("Odd: " + partitioned.get(false));
}
}13. Numeric Streams and Statistics
Java provides specialized streams such as IntStream, LongStream, and DoubleStream for primitive numeric values.
import java.util.stream.IntStream;
public class NumericStreamExample {
public static void main(String[] args) {
IntStream numbers = IntStream.of(
10, 20, 30, 40, 50
);
int sum = numbers.sum();
System.out.println("Sum: " + sum);
IntStream anotherStream = IntStream.of(
10, 20, 30, 40, 50
);
System.out.println(
"Average: " + anotherStream.average().orElse(0)
);
}
}14. Parallel Streams
parallelStream() allows a collection to be processed using parallel execution. It can be useful for suitable CPU-intensive operations over sufficiently large datasets, but parallelism introduces overhead and is not automatically faster.
import java.util.List;
public class ParallelStreamExample {
public static void main(String[] args) {
List<Integer> numbers = List.of(
1, 2, 3, 4, 5, 6, 7, 8
);
numbers.parallelStream()
.map(number -> number * number)
.forEach(System.out::println);
}
}Avoid relying on ordering or shared mutable state inside parallel stream operations unless the operation explicitly supports those requirements.
15. Java Stream Performance Considerations
Streams improve readability and provide powerful composition, but they are not automatically faster than traditional loops.
Avoid unnecessary streams: Simple loops can be clearer for very small operations or complex stateful algorithms.
Prefer primitive streams: IntStream, LongStream, and DoubleStream can avoid some boxing overhead for numeric processing.
Be careful with parallel streams: Parallel execution has scheduling and coordination costs and should be evaluated against the actual workload.
Avoid side effects: Stream pipelines are easier to reason about when operations transform data rather than mutating shared state.
16. Complete Stream Processing Example
The following example combines filtering, mapping, sorting, and collecting into one practical pipeline.
import java.util.List;
public class CompleteStreamExample {
public static void main(String[] args) {
List<String> names = List.of(
"Alice",
"Bob",
"Andrew",
"Charlie",
"Amanda",
"Brian"
);
List<String> result = names.stream()
.filter(name -> name.length() >= 5)
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.sorted()
.toList();
System.out.println(result);
}
}Conclusion
The Java Streams API provides a concise and composable approach to data processing. Core operations such as filter, map, flatMap, sorted, reduce, collect, groupingBy, and partitioningBy cover a wide range of everyday data-processing requirements.
Streams are most effective when pipelines remain readable, operations avoid unnecessary side effects, and parallel execution is used only when the workload benefits from it.