50 Java Stream Scenario based Programs with Explanations

1. Find the k most frequent elements in a list

int k = 3;

List<Integer> topK = list.stream()

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))

.entrySet().stream()

.sorted(Map.Entry.<Integer, Long>comparingByValue().reversed())

.limit(k)

.map(Map.Entry::getKey)

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: find the k most frequent elements in a list.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

2. Implement a custom collector to get summary statistics of string lengths

Collector<String, ?, IntSummaryStatistics> summaryCollector =

Collectors.summarizingInt(String::length);

IntSummaryStatistics stats = list.stream().collect(summaryCollector);

Explanation:

This problem demonstrates how to use Java Streams for: implement a custom collector to get summary

statistics of string lengths.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on
the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

3. Find all distinct permutations of characters in each string

List<String> permutations = list.stream()

.flatMap(s -> permute(s).stream())

.distinct()

.collect(Collectors.toList());

// Assume permute is a custom method returning all permutations of a string

Explanation:

This problem demonstrates how to use Java Streams for: find all distinct permutations of characters in each

string.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

4. Batch process a large stream in fixed-size chunks (e.g., 100 items each)

AtomicInteger counter = new AtomicInteger();

Map<Integer, List<String>> batches = list.stream()

.collect(Collectors.groupingBy(i -> counter.getAndIncrement() / 100));

Explanation:

This problem demonstrates how to use Java Streams for: batch process a large stream in fixed-size chunks

(e.g., 100 items each).

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

5. Create a time-windowed stream from timestamped events

Map<Long, List<Event>> windows = events.stream()

.collect(Collectors.groupingBy(e -> e.getTimestamp() / 60000)); // Group by minute

Explanation:

This problem demonstrates how to use Java Streams for: create a time-windowed stream from timestamped

events.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

6. Find the longest increasing subsequence using Stream (complex logic)

List<Integer> lis = new ArrayList<>();

for (Integer num : list) {

int i = Collections.binarySearch(lis, num);

if (i < 0) i = -(i + 1);

if (i == lis.size()) lis.add(num);

else lis.set(i, num);

Explanation:

This problem demonstrates how to use Java Streams for: find the longest increasing subsequence using

stream (complex logic).

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.
7. Group by multiple fields (e.g., department and designation)

Map<List<String>, List<Employee>> grouped = employees.stream()

.collect(Collectors.groupingBy(e -> Arrays.asList(e.getDepartment(),

e.getDesignation())));

Explanation:

This problem demonstrates how to use Java Streams for: group by multiple fields (e.g., department and

designation).

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

8. Flatten a hierarchical tree structure into a list using recursion and stream

List<Node> flatten(Node node) {

return Stream.concat(Stream.of(node),

node.getChildren().stream().flatMap(child -> flatten(child).stream()))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: flatten a hierarchical tree structure into a list using

recursion and stream.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

9. Parallel stream processing with thread-safe accumulation

ConcurrentMap<String, Long> result = list.parallelStream()

 .collect(Collectors.groupingByConcurrent(Function.identity(),

Collectors.counting()));

Explanation:

This problem demonstrates how to use Java Streams for: parallel stream processing with thread-safe

accumulation.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

10. Custom stream-based DSL for filtering dynamic criteria

Predicate<Employee> isManager = e -> e.getRole().equals("Manager");

Predicate<Employee> earnsAbove50k = e -> e.getSalary() > 50000;

List<Employee> filtered = employees.stream()

.filter(isManager.and(earnsAbove50k))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: custom stream-based dsl for filtering dynamic

criteria.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

11. Find common elements from two lists using streams

List<Integer> common = list1.stream()

.filter(list2::contains)

.collect(Collectors.toList());
Explanation:

This problem demonstrates how to use Java Streams for: find common elements from two lists using

streams.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

12. Convert a list of strings to a map with string lengths as values

Map<String, Integer> map = list.stream()

.collect(Collectors.toMap(Function.identity(), String::length));

Explanation:

This problem demonstrates how to use Java Streams for: convert a list of strings to a map with string lengths

as values.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

13. Calculate the product of all integers in a list

int product = list.stream()

.reduce(1, (a, b) -> a * b);

Explanation:

This problem demonstrates how to use Java Streams for: calculate the product of all integers in a list.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.
14. Partition students based on pass/fail using score > 40

Map<Boolean, List<Student>> result = students.stream()

.collect(Collectors.partitioningBy(s -> s.getScore() > 40));

Explanation:

This problem demonstrates how to use Java Streams for: partition students based on pass/fail using score >

40.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

15. Sort a list of employees by department then salary descending

List<Employee> sorted = employees.stream()

.sorted(Comparator.comparing(Employee::getDepartment)

.thenComparing(Employee::getSalary, Comparator.reverseOrder()))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: sort a list of employees by department then salary

descending.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

16. Get all manager names reporting to a particular department

List<String> managers = employees.stream()

.filter(e -> e.getDepartment().equals("Sales") && e.getRole().equals("Manager"))

.map(Employee::getName)
 .collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: get all manager names reporting to a particular

department.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

17. Group books by author and then by genre

Map<String, Map<String, List<Book>>> grouped = books.stream()

.collect(Collectors.groupingBy(Book::getAuthor,

Collectors.groupingBy(Book::getGenre)));

Explanation:

This problem demonstrates how to use Java Streams for: group books by author and then by genre.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

18. Count files by file extension

Map<String, Long> countByExt = files.stream()

.collect(Collectors.groupingBy(f -> getExtension(f.getName()),

Collectors.counting()));

Explanation:

This problem demonstrates how to use Java Streams for: count files by file extension.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on
the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

19. Find customers with more than 3 purchases

List<Customer> loyal = purchases.stream()

.collect(Collectors.groupingBy(Purchase::getCustomer, Collectors.counting()))

.entrySet().stream()

.filter(e -> e.getValue() > 3)

.map(Map.Entry::getKey)

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: find customers with more than 3 purchases.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

20. Convert a list of dates to strings in dd-MM-yyyy format

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");

List<String> formatted = dates.stream()

.map(d -> d.format(formatter))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: convert a list of dates to strings in dd-mm-yyyy

format.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

21. Filter out non-prime numbers using streams

List<Integer> primes = list.stream()

.filter(n -> IntStream.rangeClosed(2, (int)Math.sqrt(n))

.allMatch(i -> n % i != 0))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: filter out non-prime numbers using streams.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

22. Find the longest string in a list

String longest = list.stream()

.max(Comparator.comparingInt(String::length))

.orElse("");

Explanation:

This problem demonstrates how to use Java Streams for: find the longest string in a list.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

23. Calculate moving average with window size 3

List<Double> movingAvg = IntStream.range(0, list.size() - 2)

.mapToDouble(i -> (list.get(i) + list.get(i+1) + list.get(i+2)) / 3.0)

 .boxed().collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: calculate moving average with window size 3.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

24. Find all palindromes in a list

List<String> palindromes = list.stream()

.filter(s -> s.equalsIgnoreCase(new StringBuilder(s).reverse().toString()))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: find all palindromes in a list.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

25. Group employees by city and then by team size

Map<String, Map<Integer, List<Employee>>> grouped = employees.stream()

.collect(Collectors.groupingBy(Employee::getCity,

Collectors.groupingBy(e -> e.getTeam().size())));

Explanation:

This problem demonstrates how to use Java Streams for: group employees by city and then by team size.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

26. Normalize and deduplicate emails

List<String> cleanEmails = emails.stream()

.map(String::toLowerCase)

.map(e -> e.replaceAll("\s", ""))

.distinct()

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: normalize and deduplicate emails.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

27. Get all students whose names start and end with vowels

List<String> result = students.stream()

.map(Student::getName)

.filter(n -> n.matches("(?i)^[aeiou].*[aeiou]$"))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: get all students whose names start and end with

vowels.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.
28. Sum the values of a nested list structure

int sum = nestedList.stream()

.flatMap(Collection::stream)

.mapToInt(Integer::intValue)

.sum();

Explanation:

This problem demonstrates how to use Java Streams for: sum the values of a nested list structure.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

29. Get the earliest and latest transaction dates

Optional<LocalDate> min = transactions.stream()

.map(Transaction::getDate)

.min(LocalDate::compareTo);

Optional<LocalDate> max = transactions.stream()

.map(Transaction::getDate)

.max(LocalDate::compareTo);

Explanation:

This problem demonstrates how to use Java Streams for: get the earliest and latest transaction dates.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

30. Convert list of objects to comma-separated values for a field

String csv = objects.stream()

 .map(Object::toString)

.collect(Collectors.joining(", "));

Explanation:

This problem demonstrates how to use Java Streams for: convert list of objects to comma-separated values

for a field.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

31. Generate stream of all substrings of a string

List<String> substrings = IntStream.range(0, str.length())

.boxed()

.flatMap(i -> IntStream.range(i + 1, str.length() + 1).mapToObj(j ->

str.substring(i, j)))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: generate stream of all substrings of a string.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

32. Create a frequency map of digit counts in a list of numbers

Map<Integer, Long> digitCount = list.stream()

.flatMap(n -> String.valueOf(n).chars().mapToObj(c -> c - '0'))

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
Explanation:

This problem demonstrates how to use Java Streams for: create a frequency map of digit counts in a list of

numbers.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

33. Partition strings by length: short (<5), medium (5-10), long (>10)

Map<String, List<String>> partitioned = list.stream()

.collect(Collectors.groupingBy(s -> s.length() < 5 ? "short" : s.length() <= 10 ?

"medium" : "long"));

Explanation:

This problem demonstrates how to use Java Streams for: partition strings by length: short (<5), medium

(5-10), long (>10).

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

34. Find repeating characters in a string

Map<Character, Long> freq = str.chars()

.mapToObj(c -> (char)c)

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

List<Character> repeating = freq.entrySet().stream()

.filter(e -> e.getValue() > 1)

.map(Map.Entry::getKey)

.collect(Collectors.toList());
Explanation:

This problem demonstrates how to use Java Streams for: find repeating characters in a string.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

35. Zip two lists into a Map using index

Map<String, Integer> zipped = IntStream.range(0, list1.size())

.boxed()

.collect(Collectors.toMap(list1::get, list2::get));

Explanation:

This problem demonstrates how to use Java Streams for: zip two lists into a map using index.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

36. Find the first recurring element in a list

Set<Integer> seen = new HashSet<>();

Optional<Integer> firstRecurring = list.stream()

.filter(n -> !seen.add(n))

.findFirst();

Explanation:

This problem demonstrates how to use Java Streams for: find the first recurring element in a list.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.
37. Extract domain names from a list of emails

List<String> domains = emails.stream()

.map(email -> email.substring(email.indexOf("@") + 1))

.distinct()

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: extract domain names from a list of emails.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

38. Find longest common prefix of a list of strings

String prefix = list.stream()

.reduce((a, b) -> {

int i = 0;

while (i < a.length() && i < b.length() && a.charAt(i) == b.charAt(i)) i++;

return a.substring(0, i);

}).orElse("");

Explanation:

This problem demonstrates how to use Java Streams for: find longest common prefix of a list of strings.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

39. Calculate the variance of a list of integers

double avg = list.stream().mapToDouble(i -> i).average().orElse(0);

double variance = list.stream()

.mapToDouble(i -> Math.pow(i - avg, 2))

.average().orElse(0);

Explanation:

This problem demonstrates how to use Java Streams for: calculate the variance of a list of integers.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

40. Find the top 3 longest words in a paragraph

List<String> top3Words = Arrays.stream(paragraph.split("\s+"))

.sorted(Comparator.comparingInt(String::length).reversed())

.limit(3)

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: find the top 3 longest words in a paragraph.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

41. Detect circular references in a list of parent-child relationships

Set<String> visited = new HashSet<>();

boolean hasCycle = relations.stream()

.anyMatch(r -> !visited.add(r.getParent() + "->" + r.getChild()));

Explanation:
This problem demonstrates how to use Java Streams for: detect circular references in a list of parent-child

relationships.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

42. Calculate median of a list using streams

List<Integer> sorted = list.stream().sorted().collect(Collectors.toList());

double median = list.size() % 2 == 0 ?

(sorted.get(list.size()/2 - 1) + sorted.get(list.size()/2)) / 2.0 :

sorted.get(list.size()/2);

Explanation:

This problem demonstrates how to use Java Streams for: calculate median of a list using streams.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

43. Create a map of initials to concatenated names

Map<Character, String> map = names.stream()

.collect(Collectors.groupingBy(n -> n.charAt(0),

Collectors.mapping(Function.identity(), Collectors.joining(", "))));

Explanation:

This problem demonstrates how to use Java Streams for: create a map of initials to concatenated names.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.
44. Find the second most frequent element

String secondMost = list.stream()

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))

.entrySet().stream()

.sorted(Map.Entry.<String, Long>comparingByValue().reversed())

.skip(1).findFirst().map(Map.Entry::getKey).orElse(null);

Explanation:

This problem demonstrates how to use Java Streams for: find the second most frequent element.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

45. Identify anagrams in a list of strings

Map<String, List<String>> anagrams = list.stream()

.collect(Collectors.groupingBy(s -> s.chars().sorted()

.collect(StringBuilder::new, StringBuilder::appendCodePoint,

StringBuilder::append).toString()));

Explanation:

This problem demonstrates how to use Java Streams for: identify anagrams in a list of strings.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

46. Create a suffix tree-like structure from list of strings

Map<String, List<String>> suffixMap = list.stream()

.flatMap(word -> IntStream.range(0, word.length())

 .mapToObj(i -> new AbstractMap.SimpleEntry<>(word.substring(i), word)))

.collect(Collectors.groupingBy(Map.Entry::getKey,

Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

Explanation:

This problem demonstrates how to use Java Streams for: create a suffix tree-like structure from list of strings.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

47. Get all possible pairs of two lists using flatMap

List<String> pairs = list1.stream()

.flatMap(a -> list2.stream().map(b -> a + "-" + b))

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: get all possible pairs of two lists using flatmap.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

48. Group employees by age range buckets (20-29, 30-39...)

Map<String, List<Employee>> grouped = employees.stream()

.collect(Collectors.groupingBy(e -> {

int age = e.getAge();

return (age / 10) * 10 + "-" + ((age / 10) * 10 + 9);

}));
Explanation:

This problem demonstrates how to use Java Streams for: group employees by age range buckets (20-29,

30-39...).

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

49. Extract hashtags from a list of tweets

List<String> hashtags = tweets.stream()

.flatMap(tweet -> Arrays.stream(tweet.split(" ")))

.filter(word -> word.startsWith("#"))

.distinct()

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: extract hashtags from a list of tweets.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.

50. Remove consecutive duplicates from a list using streams

List<Integer> result = IntStream.range(0, list.size())

.filter(i -> i == 0 || !list.get(i).equals(list.get(i - 1)))

.mapToObj(list::get)

.collect(Collectors.toList());

Explanation:

This problem demonstrates how to use Java Streams for: remove consecutive duplicates from a list using
streams.

The key Stream operations involved include mapping, filtering, grouping, reducing, or flatMapping based on

the use case.

This is useful in real-world applications like analytics, processing, or building backend logic for services.