Stream Operations

Stream Collect

After filtering and transforming stream elements, you typically need to gather results into a collection or compute aggregate values. The collect operation provides flexible, efficient ways to accumulate stream results.

Basic Collectors

The collect operation is a terminal operation that uses a Collector to gather elements. The Collectors utility class provides common collectors for lists, sets, and maps.

words
Basic.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Basic {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "apple", "cherry", "banana");

        List<String> list = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("list: " + list);

        Set<String> set = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));
        System.out.println("set: " + set);

        List<String> items = Arrays.asList("a", "bb", "ccc");
        Map<String, Integer> lengths = items.stream()
                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));
        System.out.println("lengths: " + lengths);

    }
}

import java.util.*;
import java.util.stream.*;

public class Basic {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("red", "blue", "red", "green");

        List<String> list = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("list: " + list);

        Set<String> set = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));
        System.out.println("set: " + set);

        List<String> items = Arrays.asList("a", "bb", "ccc");
        Map<String, Integer> lengths = items.stream()
                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));
        System.out.println("lengths: " + lengths);

    }
}

import java.util.*;
import java.util.stream.*;

public class Basic {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("java", "stream");

        List<String> list = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("list: " + list);

        Set<String> set = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));
        System.out.println("set: " + set);

        List<String> items = Arrays.asList("a", "bb", "ccc");
        Map<String, Integer> lengths = items.stream()
                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));
        System.out.println("lengths: " + lengths);

    }
}

  1. words ← [apple, banana, apple, cherry, banana], list ← [APPLE, BANANA, APPLE, CHERRY, BANANA]

    4public class Basic {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, apple, cherry, banana] = Arrays.asList("apple", "banana", "apple", "cherry", "banana"); //@words=Arrays.asList("apple", "banana", "apple", "cherry", "banana"), Arrays.asList("red", "blue", "red", "green"), Arrays.asList("java", "stream")78        List<String> list→ [APPLE, BANANA, APPLE, CHERRY, BANANA] = words.stream()9                .map(String::toUpperCase)10                .collect(Collectors.toList());11        System.out.println("list: " + list[APPLE, BANANA, APPLE, CHERRY, BANANA]);1213        Set<String> set→ [apple, banana, cherry] = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));14        System.out.println("set: " + set[apple, banana, cherry]);1516        List<String> items→ [a, bb, ccc] = Arrays.asList("a", "bb", "ccc");17        Map<String, Integer> lengths→ {a=1, bb=2, ccc=3} = items.stream()18                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));19        System.out.println("lengths: " + lengths{a=1, bb=2, ccc=3});
    outputlist: [APPLE, BANANA, APPLE, CHERRY, BANANA]
set: [apple, banana, cherry]
lengths: {a=1, bb=2, ccc=3}

  1. words ← [red, blue, red, green], list ← [RED, BLUE, RED, GREEN]

    4public class Basic {5    public static void main(String[] args) {6        List<String> words→ [red, blue, red, green] = Arrays.asList("red", "blue", "red", "green");78        List<String> list→ [RED, BLUE, RED, GREEN] = words.stream()9                .map(String::toUpperCase)10                .collect(Collectors.toList());11        System.out.println("list: " + list[RED, BLUE, RED, GREEN]);1213        Set<String> set→ [red, blue, green] = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));14        System.out.println("set: " + set[red, blue, green]);1516        List<String> items→ [a, bb, ccc] = Arrays.asList("a", "bb", "ccc");17        Map<String, Integer> lengths→ {a=1, bb=2, ccc=3} = items.stream()18                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));19        System.out.println("lengths: " + lengths{a=1, bb=2, ccc=3});
    outputlist: [RED, BLUE, RED, GREEN]
set: [red, blue, green]
lengths: {a=1, bb=2, ccc=3}

  1. words ← [java, stream], list ← [JAVA, STREAM], set ← [java, stream]

    4public class Basic {5    public static void main(String[] args) {6        List<String> words→ [java, stream] = Arrays.asList("java", "stream");78        List<String> list→ [JAVA, STREAM] = words.stream()9                .map(String::toUpperCase)10                .collect(Collectors.toList());11        System.out.println("list: " + list[JAVA, STREAM]);1213        Set<String> set→ [java, stream] = words.stream().collect(Collectors.toCollection(LinkedHashSet::new));14        System.out.println("set: " + set[java, stream]);1516        List<String> items→ [a, bb, ccc] = Arrays.asList("a", "bb", "ccc");17        Map<String, Integer> lengths→ {a=1, bb=2, ccc=3} = items.stream()18                .collect(Collectors.toMap(s -> s, String::length, (a, b) -> a, LinkedHashMap::new));19        System.out.println("lengths: " + lengths{a=1, bb=2, ccc=3});
    outputlist: [JAVA, STREAM]
set: [java, stream]
lengths: {a=1, bb=2, ccc=3}
collector A recipe for how to accumulate stream elements into a result container, such as a list, set, map, or custom structure.
toMap A collector that builds a Map from stream elements using key and value mapper functions.

Joining Strings

The joining collector concatenates strings with optional delimiter, prefix, and suffix.

delimiter
Joining.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Joining {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String delimiter = ", ";

        String concat = words.stream().collect(Collectors.joining());
        System.out.println("concat: " + concat);

        String csv = words.stream().collect(Collectors.joining(delimiter));
        System.out.println("csv: " + csv);

        String bracketed = words.stream()
                .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("bracketed: " + bracketed);

        List<Integer> nums = Arrays.asList(1, 2, 3);
        String result = nums.stream()
                .map(n -> "num" + n)
                .collect(Collectors.joining(" | "));
        System.out.println("result: " + result);

    }
}

import java.util.*;
import java.util.stream.*;

public class Joining {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String delimiter = " | ";

        String concat = words.stream().collect(Collectors.joining());
        System.out.println("concat: " + concat);

        String csv = words.stream().collect(Collectors.joining(delimiter));
        System.out.println("csv: " + csv);

        String bracketed = words.stream()
                .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("bracketed: " + bracketed);

        List<Integer> nums = Arrays.asList(1, 2, 3);
        String result = nums.stream()
                .map(n -> "num" + n)
                .collect(Collectors.joining(" | "));
        System.out.println("result: " + result);

    }
}

import java.util.*;
import java.util.stream.*;

public class Joining {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String delimiter = "";

        String concat = words.stream().collect(Collectors.joining());
        System.out.println("concat: " + concat);

        String csv = words.stream().collect(Collectors.joining(delimiter));
        System.out.println("csv: " + csv);

        String bracketed = words.stream()
                .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("bracketed: " + bracketed);

        List<Integer> nums = Arrays.asList(1, 2, 3);
        String result = nums.stream()
                .map(n -> "num" + n)
                .collect(Collectors.joining(" | "));
        System.out.println("result: " + result);

    }
}

  1. words ← [apple, banana, cherry], delimiter ← , , concat ← applebananacherry

    4public class Joining {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String delimiter→ ,  = ", "; //@delimiter=", ", " | ", ""89        String concat→ applebananacherry = words.stream().collect(Collectors.joining());10        System.out.println("concat: " + concatapplebananacherry);1112        String csv→ apple, banana, cherry = words.stream().collect(Collectors.joining(delimiter, ));13        System.out.println("csv: " + csvapple, banana, cherry);1415        String bracketed→ [apple, banana, cherry] = words.stream()16                .collect(Collectors.joining(", ", "[", "]"));17        System.out.println("bracketed: " + bracketed[apple, banana, cherry]);1819        List<Integer> nums→ [1, 2, 3] = Arrays.asList(1, 2, 3);20        String result→ num1 | num2 | num3 = nums.stream()21                .map(n -> "num" + n)22                .collect(Collectors.joining(" | "));23        System.out.println("result: " + resultnum1 | num2 | num3);
    outputconcat: applebananacherry
csv: apple, banana, cherry
bracketed: [apple, banana, cherry]
result: num1 | num2 | num3

  1. words ← [apple, banana, cherry], delimiter ← | , concat ← applebananacherry

    4public class Joining {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String delimiter→  |  = " | ";89        String concat→ applebananacherry = words.stream().collect(Collectors.joining());10        System.out.println("concat: " + concatapplebananacherry);1112        String csv→ apple | banana | cherry = words.stream().collect(Collectors.joining(delimiter | ));13        System.out.println("csv: " + csvapple | banana | cherry);1415        String bracketed→ [apple, banana, cherry] = words.stream()16                .collect(Collectors.joining(", ", "[", "]"));17        System.out.println("bracketed: " + bracketed[apple, banana, cherry]);1819        List<Integer> nums→ [1, 2, 3] = Arrays.asList(1, 2, 3);20        String result→ num1 | num2 | num3 = nums.stream()21                .map(n -> "num" + n)22                .collect(Collectors.joining(" | "));23        System.out.println("result: " + resultnum1 | num2 | num3);
    outputconcat: applebananacherry
csv: apple | banana | cherry
bracketed: [apple, banana, cherry]
result: num1 | num2 | num3

  1. words ← [apple, banana, cherry], delimiter ← (empty), concat ← applebananacherry

    4public class Joining {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String delimiter→ (empty) = "";89        String concat→ applebananacherry = words.stream().collect(Collectors.joining());10        System.out.println("concat: " + concatapplebananacherry);1112        String csv→ applebananacherry = words.stream().collect(Collectors.joining(delimiter(empty)));13        System.out.println("csv: " + csvapplebananacherry);1415        String bracketed→ [apple, banana, cherry] = words.stream()16                .collect(Collectors.joining(", ", "[", "]"));17        System.out.println("bracketed: " + bracketed[apple, banana, cherry]);1819        List<Integer> nums→ [1, 2, 3] = Arrays.asList(1, 2, 3);20        String result→ num1 | num2 | num3 = nums.stream()21                .map(n -> "num" + n)22                .collect(Collectors.joining(" | "));23        System.out.println("result: " + resultnum1 | num2 | num3);
    outputconcat: applebananacherry
csv: applebananacherry
bracketed: [apple, banana, cherry]
result: num1 | num2 | num3

Grouping

Group elements by a classification function into a Map<K, List<T>>.

words
Grouping.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Grouping {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "apricot", "banana", "blueberry", "cherry");

        Map<Character, List<String>> byFirstLetter = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));
        System.out.println("byFirstLetter: " + byFirstLetter);

        Map<Integer, List<String>> byLength = words.stream()
                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));
        System.out.println("byLength: " + byLength);

        Map<Character, Long> counts = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));
        System.out.println("counts: " + counts);

        Map<Character, Double> avgLengths = words.stream()
                .collect(Collectors.groupingBy(
                        w -> w.charAt(0),
                        TreeMap::new,
                        Collectors.averagingInt(String::length)
                ));
        System.out.println("avgLengths: " + avgLengths);

    }
}

import java.util.*;
import java.util.stream.*;

public class Grouping {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("car", "cat", "dog", "door");

        Map<Character, List<String>> byFirstLetter = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));
        System.out.println("byFirstLetter: " + byFirstLetter);

        Map<Integer, List<String>> byLength = words.stream()
                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));
        System.out.println("byLength: " + byLength);

        Map<Character, Long> counts = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));
        System.out.println("counts: " + counts);

        Map<Character, Double> avgLengths = words.stream()
                .collect(Collectors.groupingBy(
                        w -> w.charAt(0),
                        TreeMap::new,
                        Collectors.averagingInt(String::length)
                ));
        System.out.println("avgLengths: " + avgLengths);

    }
}

import java.util.*;
import java.util.stream.*;

public class Grouping {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("red", "rose", "blue");

        Map<Character, List<String>> byFirstLetter = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));
        System.out.println("byFirstLetter: " + byFirstLetter);

        Map<Integer, List<String>> byLength = words.stream()
                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));
        System.out.println("byLength: " + byLength);

        Map<Character, Long> counts = words.stream()
                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));
        System.out.println("counts: " + counts);

        Map<Character, Double> avgLengths = words.stream()
                .collect(Collectors.groupingBy(
                        w -> w.charAt(0),
                        TreeMap::new,
                        Collectors.averagingInt(String::length)
                ));
        System.out.println("avgLengths: " + avgLengths);

    }
}

  1. words ← [apple, apricot, banana, blueberry, cherry], byFirstLetter ← {a=[apple, apricot], b=[banana, blueberry], c=[cherry]}

    4public class Grouping {5    public static void main(String[] args) {6        List<String> words→ [apple, apricot, banana, blueberry, cherry] = Arrays.asList("apple", "apricot", "banana", "blueberry", "cherry"); //@words=Arrays.asList("apple", "apricot", "banana", "blueberry", "cherry"), Arrays.asList("car", "cat", "dog", "door"), Arrays.asList("red", "rose", "blue")78        Map<Character, List<String>> byFirstLetter→ {a=[apple, apricot], b=[banana, blueberry], c=[cherry]} = words.stream()9                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));10        System.out.println("byFirstLetter: " + byFirstLetter{a=[apple, apricot], b=[banana, blueberry], c=[cherry]});1112        Map<Integer, List<String>> byLength→ {5=[apple], 6=[banana, cherry], 7=[apricot], 9=[blueberry]} = words.stream()13                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));14        System.out.println("byLength: " + byLength{5=[apple], 6=[banana, cherry], 7=[apricot], 9=[blueberry]});1516        Map<Character, Long> counts→ {a=2, b=2, c=1} = words.stream()17                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));18        System.out.println("counts: " + counts{a=2, b=2, c=1});1920        Map<Character, Double> avgLengths→ {a=6.0, b=7.5, c=6.0} = words.stream()21                .collect(Collectors.groupingBy(22                        w -> w.charAt(0),23                        TreeMap::new,24                        Collectors.averagingInt(String::length)25                ));26        System.out.println("avgLengths: " + avgLengths{a=6.0, b=7.5, c=6.0});
    outputbyFirstLetter: {a=[apple, apricot], b=[banana, blueberry], c=[cherry]}
byLength: {5=[apple], 6=[banana, cherry], 7=[apricot], 9=[blueberry]}
counts: {a=2, b=2, c=1}
avgLengths: {a=6.0, b=7.5, c=6.0}

  1. words ← [car, cat, dog, door], byFirstLetter ← {c=[car, cat], d=[dog, door]}

    4public class Grouping {5    public static void main(String[] args) {6        List<String> words→ [car, cat, dog, door] = Arrays.asList("car", "cat", "dog", "door");78        Map<Character, List<String>> byFirstLetter→ {c=[car, cat], d=[dog, door]} = words.stream()9                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));10        System.out.println("byFirstLetter: " + byFirstLetter{c=[car, cat], d=[dog, door]});1112        Map<Integer, List<String>> byLength→ {3=[car, cat, dog], 4=[door]} = words.stream()13                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));14        System.out.println("byLength: " + byLength{3=[car, cat, dog], 4=[door]});1516        Map<Character, Long> counts→ {c=2, d=2} = words.stream()17                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));18        System.out.println("counts: " + counts{c=2, d=2});1920        Map<Character, Double> avgLengths→ {c=3.0, d=3.5} = words.stream()21                .collect(Collectors.groupingBy(22                        w -> w.charAt(0),23                        TreeMap::new,24                        Collectors.averagingInt(String::length)25                ));26        System.out.println("avgLengths: " + avgLengths{c=3.0, d=3.5});
    outputbyFirstLetter: {c=[car, cat], d=[dog, door]}
byLength: {3=[car, cat, dog], 4=[door]}
counts: {c=2, d=2}
avgLengths: {c=3.0, d=3.5}

  1. words ← [red, rose, blue], byFirstLetter ← {b=[blue], r=[red, rose]}

    4public class Grouping {5    public static void main(String[] args) {6        List<String> words→ [red, rose, blue] = Arrays.asList("red", "rose", "blue");78        Map<Character, List<String>> byFirstLetter→ {b=[blue], r=[red, rose]} = words.stream()9                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.toList()));10        System.out.println("byFirstLetter: " + byFirstLetter{b=[blue], r=[red, rose]});1112        Map<Integer, List<String>> byLength→ {3=[red], 4=[rose, blue]} = words.stream()13                .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));14        System.out.println("byLength: " + byLength{3=[red], 4=[rose, blue]});1516        Map<Character, Long> counts→ {b=1, r=2} = words.stream()17                .collect(Collectors.groupingBy(w -> w.charAt(0), TreeMap::new, Collectors.counting()));18        System.out.println("counts: " + counts{b=1, r=2});1920        Map<Character, Double> avgLengths→ {b=4.0, r=3.5} = words.stream()21                .collect(Collectors.groupingBy(22                        w -> w.charAt(0),23                        TreeMap::new,24                        Collectors.averagingInt(String::length)25                ));26        System.out.println("avgLengths: " + avgLengths{b=4.0, r=3.5});
    outputbyFirstLetter: {b=[blue], r=[red, rose]}
byLength: {3=[red], 4=[rose, blue]}
counts: {b=1, r=2}
avgLengths: {b=4.0, r=3.5}
groupingBy A collector that partitions elements into a Map where keys are computed by a classifier function.

Partitioning

Partition elements into two groups based on a predicate: Map<Boolean, List<T>>.

minWordLength
Partitioning.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Partitioning {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minWordLength = 3;

        Map<Boolean, List<Integer>> partitioned = nums.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println("evens: " + partitioned.get(true));
        System.out.println("odds: " + partitioned.get(false));

        List<String> words = Arrays.asList("a", "bb", "ccc", "d", "eeee");
        Map<Boolean, List<String>> longWords = words.stream()
                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));
        System.out.println("longWords: " + longWords);

        Map<Boolean, Long> counts = nums.stream()
                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));
        System.out.println("counts: " + counts);

    }
}

import java.util.*;
import java.util.stream.*;

public class Partitioning {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minWordLength = 2;

        Map<Boolean, List<Integer>> partitioned = nums.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println("evens: " + partitioned.get(true));
        System.out.println("odds: " + partitioned.get(false));

        List<String> words = Arrays.asList("a", "bb", "ccc", "d", "eeee");
        Map<Boolean, List<String>> longWords = words.stream()
                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));
        System.out.println("longWords: " + longWords);

        Map<Boolean, Long> counts = nums.stream()
                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));
        System.out.println("counts: " + counts);

    }
}

import java.util.*;
import java.util.stream.*;

public class Partitioning {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minWordLength = 5;

        Map<Boolean, List<Integer>> partitioned = nums.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println("evens: " + partitioned.get(true));
        System.out.println("odds: " + partitioned.get(false));

        List<String> words = Arrays.asList("a", "bb", "ccc", "d", "eeee");
        Map<Boolean, List<String>> longWords = words.stream()
                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));
        System.out.println("longWords: " + longWords);

        Map<Boolean, Long> counts = nums.stream()
                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));
        System.out.println("counts: " + counts);

    }
}

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minWordLength ← 3, partitioned ← {false=[1, 3, 5, 7], true=[2, 4, 6, 8]}

    4public class Partitioning {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minWordLength→ 3 = 3; //@minWordLength=3, 2, 589        Map<Boolean, List<Integer>> partitioned→ {false=[1, 3, 5, 7], true=[2, 4, 6, 8]} = nums.stream()10                .collect(Collectors.partitioningBy(n -> n % 2 == 0));11        System.out.println("evens: " + partitioned.get(true));12        System.out.println("odds: " + partitioned.get(false));1314        List<String> words→ [a, bb, ccc, d, eeee] = Arrays.asList("a", "bb", "ccc", "d", "eeee");15        Map<Boolean, List<String>> longWords→ {false=[a, bb, d], true=[ccc, eeee]} = words.stream()16                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));17        System.out.println("longWords: " + longWords{false=[a, bb, d], true=[ccc, eeee]});1819        Map<Boolean, Long> counts→ {false=5, true=3} = nums.stream()20                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));21        System.out.println("counts: " + counts{false=5, true=3});
    outputevens: [2, 4, 6, 8]
odds: [1, 3, 5, 7]
longWords: {false=[a, bb, d], true=[ccc, eeee]}
counts: {false=5, true=3}

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minWordLength ← 2, partitioned ← {false=[1, 3, 5, 7], true=[2, 4, 6, 8]}

    4public class Partitioning {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minWordLength→ 2 = 2;89        Map<Boolean, List<Integer>> partitioned→ {false=[1, 3, 5, 7], true=[2, 4, 6, 8]} = nums.stream()10                .collect(Collectors.partitioningBy(n -> n % 2 == 0));11        System.out.println("evens: " + partitioned.get(true));12        System.out.println("odds: " + partitioned.get(false));1314        List<String> words→ [a, bb, ccc, d, eeee] = Arrays.asList("a", "bb", "ccc", "d", "eeee");15        Map<Boolean, List<String>> longWords→ {false=[a, d], true=[bb, ccc, eeee]} = words.stream()16                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));17        System.out.println("longWords: " + longWords{false=[a, d], true=[bb, ccc, eeee]});1819        Map<Boolean, Long> counts→ {false=5, true=3} = nums.stream()20                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));21        System.out.println("counts: " + counts{false=5, true=3});
    outputevens: [2, 4, 6, 8]
odds: [1, 3, 5, 7]
longWords: {false=[a, d], true=[bb, ccc, eeee]}
counts: {false=5, true=3}

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minWordLength ← 5, partitioned ← {false=[1, 3, 5, 7], true=[2, 4, 6, 8]}

    4public class Partitioning {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minWordLength→ 5 = 5;89        Map<Boolean, List<Integer>> partitioned→ {false=[1, 3, 5, 7], true=[2, 4, 6, 8]} = nums.stream()10                .collect(Collectors.partitioningBy(n -> n % 2 == 0));11        System.out.println("evens: " + partitioned.get(true));12        System.out.println("odds: " + partitioned.get(false));1314        List<String> words→ [a, bb, ccc, d, eeee] = Arrays.asList("a", "bb", "ccc", "d", "eeee");15        Map<Boolean, List<String>> longWords→ {false=[a, bb, ccc, d, eeee], true=[]} = words.stream()16                .collect(Collectors.partitioningBy(s -> s.length() >= minWordLength));17        System.out.println("longWords: " + longWords{false=[a, bb, ccc, d, eeee], true=[]});1819        Map<Boolean, Long> counts→ {false=5, true=3} = nums.stream()20                .collect(Collectors.partitioningBy(n -> n > 5, Collectors.counting()));21        System.out.println("counts: " + counts{false=5, true=3});
    outputevens: [2, 4, 6, 8]
odds: [1, 3, 5, 7]
longWords: {false=[a, bb, ccc, d, eeee], true=[]}
counts: {false=5, true=3}

Aggregations with Downstream Collectors

Combine grouping with downstream collectors for powerful aggregations.

nums
Aggregations.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Aggregations {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);

        long count = nums.stream().collect(Collectors.counting());
        System.out.println("count: " + count);

        int sum = nums.stream().collect(Collectors.summingInt(Integer::intValue));
        System.out.println("sum: " + sum);

        double avg = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));
        System.out.println("avg: " + avg);

        IntSummaryStatistics stats = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));
        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +
                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());

    }
}

import java.util.*;
import java.util.stream.*;

public class Aggregations {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(10, 20, 30);

        long count = nums.stream().collect(Collectors.counting());
        System.out.println("count: " + count);

        int sum = nums.stream().collect(Collectors.summingInt(Integer::intValue));
        System.out.println("sum: " + sum);

        double avg = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));
        System.out.println("avg: " + avg);

        IntSummaryStatistics stats = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));
        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +
                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());

    }
}

import java.util.*;
import java.util.stream.*;

public class Aggregations {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(2, 2, 8);

        long count = nums.stream().collect(Collectors.counting());
        System.out.println("count: " + count);

        int sum = nums.stream().collect(Collectors.summingInt(Integer::intValue));
        System.out.println("sum: " + sum);

        double avg = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));
        System.out.println("avg: " + avg);

        IntSummaryStatistics stats = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));
        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +
                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());

    }
}

  1. nums ← [1, 2, 3, 4, 5], count ← 5, sum ← 15, avg ← 3.0, stats ← IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}

    4public class Aggregations {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5] = Arrays.asList(1, 2, 3, 4, 5); //@nums=Arrays.asList(1, 2, 3, 4, 5), Arrays.asList(10, 20, 30), Arrays.asList(2, 2, 8)78        long count→ 5 = nums.stream().collect(Collectors.counting());9        System.out.println("count: " + count5);1011        int sum→ 15 = nums.stream().collect(Collectors.summingInt(Integer::intValue));12        System.out.println("sum: " + sum15);1314        double avg→ 3.0 = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));15        System.out.println("avg: " + avg3.0);1617        IntSummaryStatistics stats→ IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5} = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));18        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +19                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());
    outputcount: 5
sum: 15
avg: 3.0
stats: count=5, sum=15, min=1, max=5, avg=3.0

  1. nums ← [10, 20, 30], count ← 3, sum ← 60, avg ← 20.0, stats ← IntSummaryStatistics{count=3, sum=60, min=10, average=20.000000, max=30}

    4public class Aggregations {5    public static void main(String[] args) {6        List<Integer> nums→ [10, 20, 30] = Arrays.asList(10, 20, 30);78        long count→ 3 = nums.stream().collect(Collectors.counting());9        System.out.println("count: " + count3);1011        int sum→ 60 = nums.stream().collect(Collectors.summingInt(Integer::intValue));12        System.out.println("sum: " + sum60);1314        double avg→ 20.0 = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));15        System.out.println("avg: " + avg20.0);1617        IntSummaryStatistics stats→ IntSummaryStatistics{count=3, sum=60, min=10, average=20.000000, max=30} = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));18        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +19                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());
    outputcount: 3
sum: 60
avg: 20.0
stats: count=3, sum=60, min=10, max=30, avg=20.0

  1. nums ← [2, 2, 8], count ← 3, sum ← 12, avg ← 4.0, stats ← IntSummaryStatistics{count=3, sum=12, min=2, average=4.000000, max=8}

    4public class Aggregations {5    public static void main(String[] args) {6        List<Integer> nums→ [2, 2, 8] = Arrays.asList(2, 2, 8);78        long count→ 3 = nums.stream().collect(Collectors.counting());9        System.out.println("count: " + count3);1011        int sum→ 12 = nums.stream().collect(Collectors.summingInt(Integer::intValue));12        System.out.println("sum: " + sum12);1314        double avg→ 4.0 = nums.stream().collect(Collectors.averagingDouble(Integer::doubleValue));15        System.out.println("avg: " + avg4.0);1617        IntSummaryStatistics stats→ IntSummaryStatistics{count=3, sum=12, min=2, average=4.000000, max=8} = nums.stream().collect(Collectors.summarizingInt(Integer::intValue));18        System.out.println("stats: count=" + stats.getCount() + ", sum=" + stats.getSum() +19                ", min=" + stats.getMin() + ", max=" + stats.getMax() + ", avg=" + stats.getAverage());
    outputcount: 3
sum: 12
avg: 4.0
stats: count=3, sum=12, min=2, max=8, avg=4.0
downstream A secondary collector applied to grouped elements, enabling multi-level aggregation.

Exercise: Practical.java

Collect transaction data grouped by category with totals and counts