Mastering Java Streams: Real-Life Examples and Techniques
Why Use Streams?
In today’s fast-paced development environment, writing clean, efficient, and scalable code is paramount. Java Streams offer a functional paradigm for processing collections, allowing developers to handle data transformations and complex logic with ease. By reducing boilerplate code, Streams improve readability and maintainability, making them an essential tool for modern Java programming. From filtering data to aggregating results, Streams simplify common tasks while unlocking powerful possibilities for advanced use cases—whether you’re parsing large datasets or streamlining business logic.
Let’s explore some practical ways to leverage Java Streams for common tasks and advanced operations.
1. Filtering and Matching
- Filter elements based on a condition:
List<Integer> evens = list.stream() .filter(n -> n % 2 == 0) .toList(); - Find any match, all matches, or none:
boolean hasNegative = list.stream().anyMatch(n -> n < 0); boolean allPositive = list.stream().allMatch(n -> n > 0); boolean noneNegative = list.stream().noneMatch(n -> n < 0);
2. Mapping (Transforming Data)
- Transform elements using
map:List<String> strings = list.stream() .map(Object::toString) .toList(); - Flatten nested streams with
flatMap:List<List<Integer>> nested = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4) ); List<Integer> flat = nested.stream() .flatMap(Collection::stream) .toList();
3. Collecting Results
- To a list or set:
Set<Integer> uniqueElements = list.stream() .collect(Collectors.toSet()); - Grouping elements by a property:
Map<Boolean, List<Integer>> groupedByEvenOdd = list1.stream() .collect(Collectors.partitioningBy(e -> e % 2 == 0)); System.out.println("Evens: " + groupedByEvenOdd.get(true)); System.out.println("Odds: " + groupedByEvenOdd.get(false)); - Joining elements into a string:
String joined = list.stream() .map(Object::toString) .collect(Collectors.joining(", "));
4. Reducing (Aggregation)
- Sum or combine elements:
int sum = list.stream() .reduce(0, Integer::sum); // Initial value is 0 - Find the maximum or minimum element:
int max = list.stream() .max(Integer::compareTo) .orElseThrow(() -> new IllegalStateException("List is empty"));
5. Sorting
- Sort elements naturally or with a comparator:
List<String> sorted = list.stream() .sorted() .toList(); List<String> customSorted = list.stream() .sorted(Comparator.comparing(String::length)) .toList();
6. Iterating Through a Stream
- Perform an action on each element with
forEach:list.stream() .forEach(System.out::println);
7. Distinct and Limiting
- Remove duplicates:
List<Integer> distinct = list.stream() .distinct() .toList(); - Limit the number of results:
List<Integer> top3 = list.stream() .limit(3) .toList();
8. Parallel Streams
- Process elements concurrently for better performance:
List<Integer> doubled = list.parallelStream() .map(n -> n * 2) .toList();
9. Peek for Debugging
- Inspect elements during processing (not modifying them):
List<Integer> result = list.stream() .peek(System.out::println) .filter(n -> n > 5) .toList();
Processing lists using stream real life examples:
1. Finding Common Elements Across Two Lists:
Approach 1: Using Stream and filter
// Define the lists
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(3,4,6,7);
private List<Integer> getCommonElementsInTwoLists(List<Integer> list1, List<Integer> list2){
//Approach 1
List<Integer> commonValues1 = list1.stream()
.filter(list2::contains)
.toList(); //Output: 3,4
//Approach 2
List<Integer> common = new ArrayList<>(list1);
common.retainAll(list2); //Output: 3,4
//Approach 3
Set<Integer> set2 = new HashSet<>(list2);
List<Integer> commonValues2 = list1.stream()
.filter(set2::contains)
.toList(); //Output: 3,4
//Approach 4
List<Integer> commonValues3 = list1.stream()
.filter(e -> list2.stream().anyMatch(e::equals))
.toList();
return commonValues3; //Output: 3,4
}
Explanation:
Approach 1:
list1.stream(): Converts list1 into a Stream
.filter(list2::contains): Filters elements in list1 that are also present in list2.
.collect(Collectors.toList()): Collects the filtered values into a new List.
Approach 2: Using Stream and retainAll: Convert one list to a stream and use retainAll with the second list. This modifies one list to retain only the elements that are also in the other.
List<Integer> common = new ArrayList<>(list1);
common.retainAll(list2);
Approach 3: Using Stream and filter with Set for Efficiency: Convert one list to a Set to enhance the lookup time complexity from O(n) to O(1) (if the set has no collisions).
Set<Integer> set2 = new HashSet<>(list2);
List<Integer> common = list1.stream()
.filter(set2::contains)
.toList();
Approach 4: Using Stream and flatMap: Combine streams of both lists and use filtering to gather common elements.
//Using Lamda
List<Integer> common = list1.stream()
.filter(e -> list2.stream().anyMatch(m -> e.equals(m)))
.toList();
//Using Method Reference
List<Integer> common = list1.stream()
.filter(e -> list2.stream().anyMatch(e::equals))
..toList();
2. Find Elements Present in List1 but Not in List2 This is the inverse of finding common elements—you’re looking for elements that are unique to the first list.
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(3,4,6,7);
private List<Integer> findElementsInList1ButNotInList2(List<Integer> list1, List<Integer> list2){
return list1.stream()
.filter(e -> list2.stream().noneMatch(e::equals))
.toList(); //Output: 1,2
}
3. Combine Two Lists Without Duplicates
This creates a union of two lists, removing duplicate elements.
private List<Integer> combineDistinctElements(List<Integer> list1, List<Integer> list2){
return Stream.concat(list1.stream(),list2.stream())
.distinct()
.toList(); //Output: 1,2,3,4,6,7
}
4. Find Duplicate Elements Within a Single List If you want to identify which elements are repeated in a single list:
private List<Integer> findDuplicates(List<Integer> list1){
return list1.stream()
.filter(e -> Collections.frequency(list1, e) > 1)
.distinct()
.toList();
}
List<Integer> list1 = Arrays.asList(1, 2, 3, 2, 4, 3, 5, 1);
List<Integer> duplicates = findDuplicates(list1);
System.out.println(duplicates); // Output: [1, 2, 3]
5. Sort Two Lists and Merge into a Single Sorted List If you want to combine two lists and get them sorted:
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(3,4,6,7);
private List<Integer> mergeIntoSortedList(){
return Stream.concat(list1.stream(), list2.stream())
.sorted()
.toList(); //Output: [1,2,3,3,4,4,6,7]
}
6. Find the Maximum Element in a List
Use reduce or max to find the largest element in a list.
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
private int findMaxElementInAList(List<Integer> list1){
return list1.stream()
.max(Integer::compareTo)
.orElseThrow(() -> new RuntimeException("List is empty"));
} //Output: 4
7. Flatten a List of Lists
If you have a List<List
List<List<Integer>> nestedLists = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5),
Arrays.asList(6, 7, 8)
);
List<Integer> flatList = nestedLists.stream()
.flatMap(List::stream)
.toList();
System.out.println(flatList);
//Output: [1, 2, 3, 4, 5, 6, 7, 8]
8. Grouping Stock Data by Date
public record StockData(String symbol, String date, double price) {}
// Grouping stock data by date
private static Map<String, List<StockData>> groupStockDateByDate(List<StockData> stockDataList) {
return stockDataList.stream()
.collect(Collectors.groupingBy(StockData::date));
}
public static void main(String[] args) {
List<StockData> stockDataList = Arrays.asList(
new StockData("AAPL", "2025-03-24", 150.25),
new StockData("GOOGL", "2025-03-24", 2800.50),
new StockData("AAPL", "2025-03-25", 155.75),
new StockData("GOOGL", "2025-03-25", 2850.00),
new StockData("MSFT", "2025-03-25", 310.00)
);
Map<String, List<StockData>> stockDataByDate = groupStockDateByDate(stockDataList);
stockDataByDate.forEach((date, stocks) -> {
System.out.println("Date: " + date);
stocks.forEach(System.out::println);
});
}
Date: 2025-03-24
StockData[symbol=AAPL, date=2025-03-24, price=150.25]
StockData[symbol=GOOGL, date=2025-03-24, price=2800.5]
Date: 2025-03-25
StockData[symbol=AAPL, date=2025-03-25, price=155.75]
StockData[symbol=GOOGL, date=2025-03-25, price=2850.0]
StockData[symbol=MSFT, date=2025-03-25, price=310.0]
9. Grouping and Counting Frequency
Count the occurrences of each element in a list.
List<String> items = Arrays.asList("Apple", "Banana", "Apple", "Orange", "Banana", "Apple");
Map<String, Long> itemFrequency = items.stream()
.collect(Collectors.groupingBy(item -> item, Collectors.counting()));
System.out.println(itemFrequency);
// Output: {Apple=3, Banana=2, Orange=1}
10. Summing Values by Group
Summing financial transactions by user or category
public record Transaction(String user, String category, double amount) {}
List<Transaction> transactions = Arrays.asList(
new Transaction("Alice", "Food", 12.50),
new Transaction("Bob", "Travel", 100.00),
new Transaction("Alice", "Food", 15.75),
new Transaction("Bob", "Food", 8.25)
);
Map<String, Double> totalSpentByCategory = transactions.stream()
.collect(Collectors.groupingBy(Transaction::category, Collectors.summingDouble(Transaction::amount)));
System.out.println(totalSpentByCategory);
// Output: {Food=36.5, Travel=100.0}
11. Sorting with Custom Comparators
Sorting a list of objects by multiple properties, like sorting books by title and then by price.
public record Book(String title, double price) {}
List<Book> books = Arrays.asList(
new Book("Effective Java", 45.50),
new Book("Clean Code", 37.80),
new Book("Clean Code", 40.00)
);
List<Book> sortedBooks = books.stream()
.sorted(Comparator.comparing(Book::title).thenComparing(Book::price))
.toList();
System.out.println(sortedBooks);
// Output: [Book[title=Clean Code, price=37.8], Book[title=Clean Code, price=40.0], Book[title=Effective Java, price=45.5]]
12. Chunking a Large List
breaking a large list into smaller chunks, often useful for batch processing.
List<Integer> numbers = IntStream.rangeClosed(1, 20).boxed().toList();
int chunkSize = 5;
List<List<Integer>> chunks = IntStream.range(0, (numbers.size() + chunkSize - 1) / chunkSize)
.mapToObj(i -> numbers.subList(i * chunkSize, Math.min((i + 1) * chunkSize, numbers.size())))
.toList();
System.out.println(chunks);
// Output: [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
Explanation:
Calculate the number of chunks:
IntStream.range(0, (numbers.size() + chunkSize - 1) / chunkSize)
-
(numbers.size() + chunkSize - 1) / chunkSize, computes the total number of chunks required. This formula ensures proper rounding up for incomplete chunks. Intermediate Output: 4
-
IntStream.range(0, (numbers.size() + chunkSize - 1) / chunkSize) creates a stream of indices for each chunk. For the example where numbers.size() is 20 and chunkSize is 5, the stream will be [0,1,2,3] . Each index corresponds to a chunk.
Map each index to a sublist:
.mapToObj(i -> numbers.subList(i * chunkSize, Math.min((i + 1) * chunkSize, numbers.size())))
- For each chunk index :
- The start index of the chunk is i * chunkSize
- The end index of the chunk is Math.min((i+1) * chunkSize, numbers.size()). This ensures the end index doesn’t exceed the size of the original list.
13. Creating a CSV from a List of Objects
converting a list of objects into a CSV-like format for export or logging purposes.
List<Book> books = Arrays.asList(
new Book("Effective Java", 45.50),
new Book("Clean Code", 37.80)
);
String csv = books.stream()
.map(book -> book.title() + "," + book.price())
.collect(Collectors.joining("\n"));
System.out.println(csv);
// Output:
// Effective Java,45.5
// Clean Code,37.8
Conclusion: Java Streams empower developers to write cleaner, more efficient code for both everyday tasks and advanced operations. By simplifying data processing and improving scalability, Streams are an invaluable asset in modern Java development.
Author: Mohammad J Iqbal
