PfLearn | Collectors收集器

Collectors收集器转载

2025-03-13 11:02 7

`Collectors` 类提供了许多常用的收集器（`Collector`），它们是用于在流处理过程中进行聚合、分组、过滤等操作的工具。以下是一些常见的 `Collector` 收集器：

### 1. **`toList()`**

- **用途**：将流中的元素收集到一个 `List` 中。

- 示例

```java
  List<String> list = Stream.of("a", "b", "c")
                            .collect(Collectors.toList());
  System.out.println(list); // 输出: [a, b, c]
  ```

### 2. **`toSet()`**

- **用途**：将流中的元素收集到一个 `Set` 中（去重）。

- 示例

```java
  Set<String> set = Stream.of("a", "b", "c", "a")
                          .collect(Collectors.toSet());
  System.out.println(set); // 输出: [a, b, c]
  ```

### 3. **`toMap()`**

- **用途**：将流中的元素收集到一个 `Map` 中。需要指定如何将流的元素映射到键和值。

- 示例

```java
  Map<String, Integer> map = Stream.of("a", "b", "c")
                                   .collect(Collectors.toMap(s -> s, String::length));
  System.out.println(map); // 输出: {a=1, b=1, c=1}
  ```

### 4. **`joining()`**

- **用途**：将流中的元素连接成一个字符串，可以指定分隔符、前缀、后缀。

- 示例

```java
  java复制编辑String result = Stream.of("a", "b", "c")
                        .collect(Collectors.joining(", ", "[", "]"));
  System.out.println(result); // 输出: [a, b, c]
  ```

### 5. **`groupingBy()`**

- **用途**：按指定的分类函数将流中的元素分组，返回一个 `Map`，键是分类的结果，值是对应分类的元素。

- 示例

```java
  Map<Integer, List<String>> grouped = Stream.of("apple", "banana", "cherry")
                                             .collect(Collectors.groupingBy(String::length));
  System.out.println(grouped); // 输出: {5=[apple], 6=[banana, cherry]}
  ```

### 6. **`partitioningBy()`**

- **用途**：根据一个谓词将流中的元素分为两组，返回一个 `Map`，键为 `Boolean` 类型，值为符合该条件的元素。

- 示例

```java
  Map<Boolean, List<String>> partitioned = Stream.of("apple", "banana", "cherry")
                                                .collect(Collectors.partitioningBy(s -> s.length() > 5));
  System.out.println(partitioned); // 输出: {false=[apple], true=[banana, cherry]}
  ```

### 7. **`counting()`**

- **用途**：统计流中元素的个数。

- 示例

```java
  long count = Stream.of("apple", "banana", "cherry")
                     .collect(Collectors.counting());
  System.out.println(count); // 输出: 3
  ```

### 8. **`summarizingInt()` / `summarizingDouble()` / `summarizingLong()`**

- **用途**：对流中的元素进行统计，返回 `IntSummaryStatistics`、`DoubleSummaryStatistics` 或 `LongSummaryStatistics`。

- 示例

```java
  IntSummaryStatistics stats = Stream.of(1, 2, 3, 4, 5)
                                    .collect(Collectors.summarizingInt(Integer::intValue));
  System.out.println(stats); // 输出: IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}
  ```

### 9. **`reducing()`**

- **用途**：使用一个归约操作将流中的元素合并成一个单一的结果。

- 示例

```java
  int sum = Stream.of(1, 2, 3, 4, 5)
                  .collect(Collectors.reducing(0, Integer::sum));
  System.out.println(sum); // 输出: 15
  ```

### 10. **`mapping()`**

- **用途**：将流中的元素映射到其他类型，通常与 `groupingBy()` 或其他收集器一起使用。

- 示例

```java
  Map<Integer, List<String>> lengthGrouped = Stream.of("apple", "banana", "cherry")
                                                  .collect(Collectors.groupingBy(String::length,
                                                                                Collectors.mapping(String::toUpperCase, Collectors.toList())));
  System.out.println(lengthGrouped); // 输出: {5=[APPLE], 6=[BANANA, CHERRY]}
  ```

### 11. **`collectingAndThen()`**

- **用途**：对收集到的结果进行进一步的处理，返回一个经过处理后的结果。

- 示例

```java
  List<String> result = Stream.of("apple", "banana", "cherry")
                              .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
  System.out.println(result); // 输出: [apple, banana, cherry]
  ```

### 12. **`flatMapping()`**

- **用途**：将流中的每个元素通过映射函数转换为多个元素，并将其合并成一个流。

- 示例

```java
  List<String> result = Stream.of("apple", "banana", "cherry")
                              .collect(Collectors.flatMapping(s -> Arrays.stream(s.split("")), Collectors.toList()));
  System.out.println(result); // 输出: [a, p, p, l, e, b, a, n, a, n, a, c, h, e, r, r, y]
  ```