java8里如何使用流收集数据？《Java8 实战》读书笔记 第 6 章 用流收集数据

**Java8 流收集数据**

在 Java8 中，流（Stream）是一个非常强大的工具，可以帮助我们处理集合中的元素。流可以用来过滤、映射、聚合等操作，而这些操作都是惰性的，这意味着只有当我们真正需要结果时才会执行这些操作。

**流收集数据**

在本章，我们将学习如何使用流收集数据。收集数据是指从流中提取元素并存储到一个集合中，如 List、Set 等。

###6.1 使用 `collect()` 方法`collect()` 方法是最常用的方法来收集流中的元素。它接受一个 Collector 接口的实现作为参数，这个接口定义了如何将流中的元素收集起来。

**示例代码**

javaimport java.util.List;
import java.util.stream.Collectors;

public class CollectExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of("a", "b", "c", "d");

 // 使用 collect() 方法收集流中的元素 String result = list.stream()
 .collect(Collectors.joining());

 System.out.println(result); // 输出: abcd }
}

在这个示例中，我们使用 `collect()` 方法将流中的元素收集起来，并使用 `Collectors.joining()` 来连接这些元素，得到一个字符串。

###6.2 使用 `toCollection()` 方法`toCollection()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 Collection 接口的实现作为参数，这个接口定义了如何将流中的元素收集起来。

**示例代码**

javaimport java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ToCollectionExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of("a", "b", "c", "d");

 // 使用 toCollection() 方法收集流中的元素 List result = list.stream()
 .collect(Collectors.toCollection(ArrayList::new));

 System.out.println(result); // 输出: [a, b, c, d]
 }
}

在这个示例中，我们使用 `toCollection()` 方法将流中的元素收集起来，并使用 `Collectors.toCollection(ArrayList::new)` 来创建一个 ArrayList。

###6.3 使用 `groupingBy()` 方法`groupingBy()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 Function 接口的实现作为参数，这个接口定义了如何将流中的元素分组起来。

**示例代码**

javaimport java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupingByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of("a", "b", "c", "d");

 // 使用 groupingBy() 方法收集流中的元素 Map> result = list.stream()
 .collect(Collectors.groupingBy(s -> s.charAt(0)));

 System.out.println(result); // 输出: {a=[a], b=[b], c=[c], d=[d]}
 }
}

在这个示例中，我们使用 `groupingBy()` 方法将流中的元素收集起来，并使用 `Collectors.groupingBy(s -> s.charAt(0))` 来分组这些元素，得到一个 Map。

###6.4 使用 `partitioningBy()` 方法`partitioningBy()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 Predicate 接口的实现作为参数，这个接口定义了如何将流中的元素分区起来。

**示例代码**

javaimport java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class PartitioningByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of("a", "b", "c", "d");

 // 使用 partitioningBy() 方法收集流中的元素 Map> result = list.stream()
 .collect(Collectors.partitioningBy(s -> s.equals("a")));

 System.out.println(result); // 输出: {false=[b, c, d], true=[a]}
 }
}

在这个示例中，我们使用 `partitioningBy()` 方法将流中的元素收集起来，并使用 `Collectors.partitioningBy(s -> s.equals("a"))` 来分区这些元素，得到一个 Map。

###6.5 使用 `summarizingDouble()` 方法`summarizingDouble()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 ToDoubleFunction 接口的实现作为参数，这个接口定义了如何将流中的元素转换为 double 值。

**示例代码**

javaimport java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class SummarizingByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of(1,2,3,4);

 // 使用 summarizingDouble() 方法收集流中的元素 Map result = list.stream()
 .collect(Collectors.summarizingDouble(i -> (double) i));

 System.out.println(result); // 输出: {count=4.0, sum=10.0}
 }
}

在这个示例中，我们使用 `summarizingDouble()` 方法将流中的元素收集起来，并使用 `Collectors.summarizingDouble(i -> (double) i)` 来转换这些元素为 double 值，得到一个 Map。

###6.6 使用 `averagingInt()` 方法`averagingInt()` 方法是另一种可以用来收集流中的元素的方法。它接受一个ToIntFunction 接口的实现作为参数，这个接口定义了如何将流中的元素转换为 int 值。

**示例代码**

javaimport java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class AveragingByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of(1,2,3,4);

 // 使用 averagingInt() 方法收集流中的元素 Map result = list.stream()
 .collect(Collectors.averagingInt(i -> i));

 System.out.println(result); // 输出: {average=2}
 }
}

在这个示例中，我们使用 `averagingInt()` 方法将流中的元素收集起来，并使用 `Collectors.averagingInt(i -> i)` 来转换这些元素为 int 值，得到一个 Map。

###6.7 使用 `maxBy()` 方法`maxBy()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 ToIntFunction 接口的实现作为参数，这个接口定义了如何将流中的元素转换为 int 值。

**示例代码**

javaimport java.util.List;
import java.util.OptionalInt;
import java.util.stream.Collectors;

public class MaxByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of(1,2,3,4);

 // 使用 maxBy() 方法收集流中的元素 OptionalInt result = list.stream()
 .collect(Collectors.maxBy(Integer::compare));

 System.out.println(result); // 输出:4 }
}

在这个示例中，我们使用 `maxBy()` 方法将流中的元素收集起来，并使用 `Collectors.maxBy(Integer::compare)` 来转换这些元素为 int 值，得到一个 OptionalInt。

###6.8 使用 `minBy()` 方法`minBy()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 ToIntFunction 接口的实现作为参数，这个接口定义了如何将流中的元素转换为 int 值。

**示例代码**

javaimport java.util.List;
import java.util.OptionalInt;
import java.util.stream.Collectors;

public class MinByExample {
 public static void main(String[] args) {
 // 创建一个列表 List list = List.of(1,2,3,4);

 // 使用 minBy() 方法收集流中的元素 OptionalInt result = list.stream()
 .collect(Collectors.minBy(Integer::compare));

 System.out.println(result); // 输出:1 }
}

在这个示例中，我们使用 `minBy()` 方法将流中的元素收集起来，并使用 `Collectors.minBy(Integer::compare)` 来转换这些元素为 int 值，得到一个 OptionalInt。

###6.9 使用 `counting()` 方法`counting()` 方法是另一种可以用来收集流中的元素的方法。它接受一个 ToIntFunction 接口的实现作为参数，这个接口定义了如何将流中的元素转换为 int 值。

**示例代码**

javaimport java.util.List;
import java.util.OptionalInt;
import java.util.stream.Collectors;

public class