Collectors.groupingBy() 分組數(shù)據(jù)，支持下游收集器進(jìn)一步處理；2. Collectors.partitioningBy() 按布爾條件分區(qū)；3. Collectors.joining() 拼接字符串，支持分隔符、前綴和后綴；4. 數(shù)值收集器如 summarizingInt() 提供統(tǒng)計(jì)信息；5. 可嵌套組合收集器實(shí)現(xiàn)復(fù)雜操作；6. collectingAndThen() 對(duì)結(jié)果執(zhí)行最終轉(zhuǎn)換，這些高級(jí)收集器能減少樣板代碼、提升性能并增強(qiáng)代碼可讀性，使數(shù)據(jù)處理更直觀高效。

Java’s Stream API is a powerful tool for processing sequences of elements, and Collectors are the key to aggregating stream results into useful forms. While Collectors.toList() and Collectors.toMap() are the most commonly used, the Collectors utility class offers a rich set of operations that go far beyond these basics. Let’s explore some of the more advanced and practical collectors that can simplify your code and improve readability.

1. Grouping Data with groupingBy()

One of the most powerful collectors is Collectors.groupingBy(), which partitions elements into groups based on a classification function.

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

Map<Integer, List<String>> groupedByLength = words.stream()
    .collect(Collectors.groupingBy(String::length));

// Result: {4=[date], 5=[apple], 6=[banana, cherry]}

You can also apply a downstream collector to further process each group:

Map<Integer, Long> countByLength = words.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

// Result: {4=1, 5=1, 6=2}

This is especially useful for summarizing data—like counting, summing, or averaging within categories.

2. Partitioning with partitioningBy()

When you need to split a stream into two groups based on a boolean condition, use partitioningBy().

Map<Boolean, List<Integer>> evenOdd = Arrays.asList(1, 2, 3, 4, 5).stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

// Result: {false=[1, 3, 5], true=[2, 4]}

Like groupingBy(), it supports downstream collectors:

Map<Boolean, Integer> sumPartition = Arrays.asList(1, 2, 3, 4, 5).stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.summingInt(Integer::intValue)
    ));

// Result: {false=9, true=6}

This is ideal for binary categorizations like pass/fail, active/inactive, etc.

3. Collecting into Strings with joining()

Need to concatenate strings from a stream? Collectors.joining() is clean and efficient.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

String joined = names.stream()
    .collect(Collectors.joining(", ", "Names: ", "."));

// Result: "Names: Alice, Bob, Charlie."

It supports:

• A delimiter (", ")
• An optional prefix ("Names: ")
• An optional suffix (".")

Perfect for building readable output or CSV-like strings.

4. Aggregating Numeric Data

Java provides specialized collectors for numeric reduction:

• Collectors.summingInt(), summingLong(), summingDouble()
• Collectors.averagingInt(), etc.
• Collectors.maxBy(), minBy() with Comparator

Example:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

IntSummaryStatistics stats = numbers.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));

// stats.getSum() → 15
// stats.getAverage() → 3.0
// stats.getMax() → 5

summarizingInt() gives you a full statistical snapshot in one pass.

5. Composing Collectors with Nesting

You can compose collectors by nesting them in groupingBy(), partitioningBy(), or mapping().

For example, group people by city and get only their names:

Map<String, List<String>> namesByCity = people.stream()
    .collect(Collectors.groupingBy(
        Person::getCity,
        Collectors.mapping(Person::getName, Collectors.toList())
    ));

Or get the average age per department:

Map<String, Double> avgAgeByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingInt(Employee::getAge)
    ));

This composability makes Collectors extremely flexible.

6. Handling Optional Results with collectingAndThen()

Sometimes you want to perform a final transformation on the result, especially when you know the result won’t be null.

String maxName = names.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.maxBy(String::compareTo),
        Optional::get
    ));

Use this to wrap a collector and apply a finishing function—handy when you want to assert or convert the final result.

Just be cautious: if the inner collector returns an empty Optional, Optional::get will throw!

Final Thoughts

While toList() and toMap() cover many basic cases, diving into the broader Collectors toolbox lets you:

• Reduce boilerplate
• Improve performance (fewer passes over data)
• Write more expressive, functional-style code

These advanced collectors are not just syntactic sugar—they enable declarative, readable data processing that closely mirrors your intent.

Basically, once you start using groupingBy, partitioningBy, and nested collectors, you’ll wonder how you lived without them.

以上是Java流收集器：超越`tolist（）和`tomap（）``的詳細(xì)內(nèi)容。更多信息請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！