Java8 Collectors类详解（二）

统计

counting()
Collectors.counting() 是 Java 8 中提供的一个工厂方法，用于创建一个统计流中元素个数的 Collector。该方法返回一个 Collector 实现，可以被传递给 Stream 的 collect 方法用于执行统计操作。

具体来说，Collectors.counting() 方法的作用是将流中元素的数量统计出来，返回一个 long 类型的结果，表示流中元素的个数。

下面是 Collectors.counting() 的示例代码：

List<String> list = Arrays.asList("apple", "banana", "orange");
long count = list.stream().collect(Collectors.counting());
System.out.println("Count: " + count);
输出结果为：

Count: 3
在上述代码中，首先创建了一个包含三个字符串元素的列表。然后使用 stream 方法创建一个流，并调用 Collectors.counting() 工厂方法对流进行统计操作，最后将统计结果输出到控制台。

需要注意的是，由于 Collectors.counting() 返回的结果是一个 Long 类型的对象，因此在使用时需要进行类型转换。

总之，Collectors.counting() 是一种非常方便的收集器，它可以快速地统计流中元素的个数，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

summingInt(ToIntFunction<? super T> mapper)
Collectors.summingInt(ToIntFunction<? super T> mapper) 是 Java 8 中提供的一个工厂方法，用于创建一个对流中元素进行整数求和操作的 Collector。

具体来说，Collectors.summingInt() 方法接受一个 ToIntFunction 函数式接口作为参数，该接口可以将流中的每个元素映射为一个 int 值，并将这些 int 值累加起来，返回一个表示总和的 int 类型结果。

下面是 Collectors.summingInt() 的示例代码：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println("Sum: " + sum);
输出结果为：

Sum: 15
在上述代码中，首先创建了包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.summingInt() 对流中元素进行求和操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.summingInt() 返回的结果是一个 int 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求和的结果。

总之，Collectors.summingInt() 是一种非常方便的收集器，它可以快速地对流中元素进行求和操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

summingLong(ToLongFunction<? super T> mapper)
summingLong(ToLongFunction<? super T> mapper) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行长整型求和操作的 Collector。

具体来说，这个方法接收一个 ToLongFunction 函数式接口作为参数，用于将流中的每个元素映射为一个 long 值，并将这些 long 值累加起来，返回一个表示总和的 long 类型结果。

下面是 summingLong 的使用示例：

List<Long> list = Arrays.asList(1L, 2L, 3L, 4L, 5L);
long sum = list.stream().collect(Collectors.summingLong(Long::longValue));
System.out.println("Sum: " + sum);
输出结果为：

Sum: 15

可以看到，在此示例中，首先创建了一个包含五个长整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.summingLong() 对流中元素进行求和操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.summingLong() 返回的结果是一个 long 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求和的结果。

总之，summingLong 是一种非常方便的收集器，它可以快速地对流中元素进行长整型求和操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

summingDouble(ToDoubleFunction<? super T> mapper)
summingDouble(ToDoubleFunction<? super T> mapper) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行 double 值求和操作的 Collector。

具体来说，这个方法接收一个 ToDoubleFunction 函数式接口作为参数，用于将流中的每个元素映射为一个 double 值，并将这些 double 值累加起来，返回一个表示总和的 double 类型结果。

下面是 summingDouble 的使用示例：

List<Double> list = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
double sum = list.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println("Sum: " + sum);
输出结果为：

Sum: 15.0
可以看到，在此示例中，首先创建了一个包含五个 Double 类型元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.summingDouble() 对流中元素进行求和操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.summingDouble() 返回的结果是一个 double 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求和的结果。

总之，summingDouble 是一种非常方便的收集器，它可以快速地对流中元素进行 double 值求和操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

 

averagingInt(ToIntFunction<? super T> mapper)
averagingInt(ToIntFunction<? super T> mapper) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行整数平均值求取操作的 Collector。

具体来说，这个方法接收一个 ToIntFunction 函数式接口作为参数，用于将流中的每个元素映射为一个 int 值，并将这些 int 值求和并计算其平均值，返回一个表示平均值的 double 类型结果。

下面是 averagingInt 的使用示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
double average = list.stream().collect(Collectors.averagingInt(Integer::intValue));
System.out.println("Average: " + average);
输出结果为：

Average: 3.0
可以看到，在此示例中，首先创建了一个包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.averagingInt() 对流中元素进行求平均值操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.averagingInt() 返回的结果是一个 double 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求平均值的结果。

总之，averagingInt 是一种非常方便的收集器，它可以快速地对流中元素进行整数平均值求取操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

averagingLong(ToLongFunction<? super T> mapper)
averagingLong(ToLongFunction<? super T> mapper) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行长整数平均值求取操作的 Collector。

具体来说，这个方法接收一个 ToLongFunction 函数式接口作为参数，用于将流中的每个元素映射为一个 long 值，并将这些 long 值求和并计算其平均值，返回一个表示平均值的 double 类型结果。

下面是 averagingLong 的使用示例：

List<Long> list = Arrays.asList(1L, 2L, 3L, 4L, 5L);
double average = list.stream().collect(Collectors.averagingLong(Long::longValue));
System.out.println("Average: " + average);
输出结果为：

Average: 3.0
可以看到，在此示例中，首先创建了一个包含五个长整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.averagingLong() 对流中元素进行求平均值操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.averagingLong() 返回的结果是一个 double 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求平均值的结果。

总之，averagingLong 是一种非常方便的收集器，它可以快速地对流中元素进行长整数平均值求取操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

 

averagingDouble(ToDoubleFunction<? super T> mapper)
averagingDouble(ToDoubleFunction<? super T> mapper) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行 double 值平均值求取操作的 Collector。

具体来说，这个方法接收一个 ToDoubleFunction 函数式接口作为参数，用于将流中的每个元素映射为一个 double 值，并将这些 double 值求和并计算其平均值，返回一个表示平均值的 double 类型结果。

下面是 averagingDouble 的使用示例：

List<Double> list = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
double average = list.stream().collect(Collectors.averagingDouble(Double::doubleValue));
System.out.println("Average: " + average);
输出结果为：

Average: 3.0
可以看到，在此示例中，首先创建了一个包含五个 Double 类型元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.averagingDouble() 对流中元素进行求平均值操作，最后将结果输出到控制台。

需要注意的是，由于 Collectors.averagingDouble() 返回的结果是一个 double 类型的结果，因此在使用时需要确保对应的数据类型可以正确地存放求平均值的结果。

总之，averagingDouble 是一种非常方便的收集器，它可以快速地对流中元素进行 double 值平均值求取操作，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

maxBy(Comparator<? super T> comparator)
maxBy(Comparator<? super T> comparator) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行比较操作并返回最大值的 Collector。

具体来说，这个方法接收一个 Comparator 函数式接口作为参数，该接口定义了一个比较方法，用于比较两个元素的大小，并返回一个表示比较结果的整数值。Collector 使用该比较器对流中的元素进行比较，并返回一个 Optional 类型的结果，包含流中最大的元素。

下面是 maxBy 的使用示例：

List<Integer> list = Arrays.asList(5, 3, 2, 8, 9);
Optional<Integer> max = list.stream().collect(Collectors.maxBy(Comparator.naturalOrder()));
System.out.println("Max: " + max.get());
输出结果为：

Max: 9
可以看到，在此示例中，首先创建了一个包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.maxBy() 对流中元素进行比较操作，找到最大值，最后将结果输出到控制台。

需要注意的是，由于 Collectors.maxBy() 返回的结果是一个 Optional 类型的结果，因此在使用时需要确保正确处理 Optional 可能为空的情况。

总之，maxBy 是一种非常方便的收集器，它可以快速地对流中元素进行比较并返回最大值，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

minBy(Comparator<? super T> comparator)
minBy(Comparator<? super T> comparator) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于创建一个对流中元素进行比较操作并返回最小值的 Collector。

具体来说，这个方法接收一个 Comparator 函数式接口作为参数，该接口定义了一个比较方法，用于比较两个元素的大小，并返回一个表示比较结果的整数值。Collector 使用该比较器对流中的元素进行比较，并返回一个 Optional 类型的结果，包含流中最小的元素。

下面是 minBy 的使用示例：

List<Integer> list = Arrays.asList(5, 3, 2, 8, 9);
Optional<Integer> min = list.stream().collect(Collectors.minBy(Comparator.naturalOrder()));
System.out.println("Min: " + min.get());
输出结果为：

Min: 2
可以看到，在此示例中，首先创建了一个包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.minBy() 对流中元素进行比较操作，找到最小值，最后将结果输出到控制台。

需要注意的是，由于 Collectors.minBy() 返回的结果是一个 Optional 类型的结果，因此在使用时需要确保正确处理 Optional 可能为空的情况。

总之，minBy 是一种非常方便的收集器，它可以快速地对流中元素进行比较并返回最小值，并且可以与其他收集器组合使用，实现更加复杂的统计功能。

 

连接

joining()
joining() 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素连接成一个字符串。

具体来说，如果需要将流中的所有元素连接成一个字符串，可以使用 Collectors.joining() 方法。该方法返回一个 Collector 对象，该对象会依次将流中的元素转换为字符串，并使用指定的分隔符将它们连接起来。最终返回的结果是一个字符串。

下面是 joining 的使用示例：

List<String> list = Arrays.asList("Java", " is", " a", " popular", " programming", " language");
String result = list.stream().collect(Collectors.joining());
System.out.println(result);
输出结果为：

Java is a popular programming language
可以看到，在此示例中，首先创建了一个包含六个字符串元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.joining() 将流中的元素连接成一个字符串，最终将结果输出到控制台。

joining(CharSequence delimiter)
joining(CharSequence delimiter) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素连接成一个字符串，并且可以指定一个分隔符。

具体来说，该方法接收一个 CharSequence 类型的参数，该参数是一个字符串，它将作为分隔符使用。Collector 对象会依次将流中的元素转换为字符串，并使用指定的分隔符将它们连接起来。最终返回的结果是一个字符串。

下面是 joining(CharSequence delimiter) 的使用示例：

List<String> list = Arrays.asList("Java", " is", " a", " popular", " programming", " language");
String result = list.stream().collect(Collectors.joining(", "));
System.out.println(result);
输出结果为：

Java, is, a, popular, programming, language
可以看到，在此示例中，首先创建了一个包含六个字符串元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.joining(", ") 将流中的元素连接成一个字符串，每个元素之间以逗号和一个空格进行分隔，最终将结果输出到控制台。

需要注意的是，在使用 joining(CharSequence delimiter) 方法时，如果希望使用空字符串作为分隔符，可以传递一个空字符串或 null 作为参数。例如：

List<String> list = Arrays.asList("Java", " is", " a", " popular", " programming", " language");
String result = list.stream().collect(Collectors.joining(""));
System.out.println(result);
输出结果为：

Java is a popular programming language
总之，joining(CharSequence delimiter) 是一种非常方便的收集器，它可以快速地将流中的元素连接成一个字符串，并且可以指定分隔符，实现更加灵活的字符串连接。

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素连接成一个字符串，并且可以指定一个分隔符、前缀和后缀。

具体来说，该方法有三个 CharSequence 类型的参数：delimiter、prefix 和 suffix。其中，delimiter 参数是一个字符串，用于指定元素之间的分隔符；prefix 参数是一个字符串，用于指定整个字符串的前缀；suffix 参数是一个字符串，用于指定整个字符串的后缀。Collector 对象会依次将流中的元素转换为字符串，并使用指定的分隔符将它们连接起来，最终将结果用前缀和后缀包裹起来，形成一个字符串。

下面是 joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 的使用示例：

List<String> list = Arrays.asList("Java", " is", " a", " popular", " programming", " language");
String result = list.stream().collect(Collectors.joining(", ", "[", "]"));
System.out.println(result);
输出结果为：

[Java, is, a, popular, programming, language]

可以看到，在此示例中，首先创建了一个包含六个字符串元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.joining(", ", "[", "]") 将流中的元素连接成一个字符串，每个元素之间以逗号和一个空格进行分隔，整个字符串以 "[" 作为前缀，以 "]" 作为后缀，最终将结果输出到控制台。

需要注意的是，在使用 joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 方法时，如果希望省略前缀或后缀，可以传递一个空字符串或 null 作为参数。例如：

List<String> list = Arrays.asList("Java", " is", " a", " popular", " programming", " language");
String result = list.stream().collect(Collectors.joining(", ", "", ""));
System.out.println(result);
输出结果为：

Java, is, a, popular, programming, language
总之，joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 是一种非常方便的收集器，它可以快速地将流中的元素连接成一个字符串，并且可以指定分隔符、前缀和后缀，实现更加灵活的字符串连接。

归约

reducing(BinaryOperator<T> op)
reducing(BinaryOperator<T> op) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素通过指定的二元操作符进行归约。

具体来说，该方法接收一个 BinaryOperator<T> 类型的参数 op，该参数是一个二元操作符，用于将两个同类型的值合并为一个。Collector 对象会依次将流中的元素转换为 T 类型的值，并使用指定的二元操作符将它们逐一合并起来。最终返回的结果是一个 Optional<T> 对象，其中封装了合并后的结果。如果流为空，则返回一个空 Optional 对象。

下面是 reducing(BinaryOperator<T> op) 的使用示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = list.stream().collect(Collectors.reducing((x, y) -> x + y));
System.out.println(result.get());
输出结果为：

15
可以看到，在此示例中，首先创建了一个包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.reducing((x, y) -> x + y) 将流中的元素通过加法操作进行归约，最终得到 15 这个整数作为结果，并使用 Optional 封装返回。

需要注意的是，如果对于非空流，使用 reducing(BinaryOperator<T> op) 和使用 reduce(BinaryOperator<T> op) 可以达到相同的效果，但是由于 reducing(BinaryOperator<T> op) 返回的是 Optional 对象，因此更加安全。

总之，reducing(BinaryOperator<T> op) 是一种非常方便的收集器，它可以通过指定的二元操作符将流中的元素逐一合并起来，实现归约操作，并使用 Optional 封装返回结果。

reducing(T identity, BinaryOperator<T> op)
reducing(T identity, BinaryOperator<T> op) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素通过指定的二元操作符进行归约，并指定一个起始值。

具体来说，该方法接收两个参数，第一个参数是类型为 T 的 identity，它代表了归约操作的起始值。第二个参数是 BinaryOperator<T> 类型的 op，它是一个二元操作符，用于将两个同类型的值合并为一个。Collector 对象会依次将流中的元素转换为 T 类型的值，并使用指定的二元操作符将它们逐一合并起来。最终返回的结果是一个 T 类型的值，它是流中所有元素进行归约操作后的结果。

下面是 reducing(T identity, BinaryOperator<T> op) 的使用示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int result = list.stream().collect(Collectors.reducing(0, (x, y) -> x + y));
System.out.println(result);
输出结果为：

15
可以看到，在此示例中，首先创建了一个包含五个整数元素的列表。然后通过 stream 方法创建一个流，并使用 Collectors.reducing(0, (x, y) -> x + y) 将流中的元素通过加法操作进行归约，起始值为 0。最终得到 15 这个整数作为结果，并输出。

需要注意的是，如果对于非空流，使用 reducing(T identity, BinaryOperator<T> op) 和使用 reduce(T identity, BinaryOperator<T> op) 可以达到相同的效果。

总之，reducing(T identity, BinaryOperator<T> op) 是一种非常方便的收集器，它可以通过指定的二元操作符将流中的元素逐一合并起来，并指定一个起始值，实现归约操作。

reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op)
reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素通过指定的二元操作符进行归约，并指定起始值和类型转换函数。

具体来说，该方法接收三个参数，第一个参数是类型为 U 的 identity，它代表了归约操作的起始值。第二个参数是 Function<? super T, ? extends U> 类型的 mapper，它用于将流中的元素 T 转换成类型为 U 的值。第三个参数是 BinaryOperator<U> 类型的 op，它是一个二元操作符，用于将两个同类型的值 U 合并为一个。Collector 对象会依次将流中的元素转换为 U 类型的值，并使用指定的二元操作符将它们逐一合并起来。最终返回的结果是一个 U 类型的值，它是流中所有元素进行归约操作后的结果。

下面是 reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op) 的使用示例：

假设我们有一个类 Person，包含姓名 name 和年龄 age 两个属性。我们想计算所有人年龄总和的平方。我们可以这样写：

List<Person> list = Arrays.asList(new Person("Alice", 20), new Person("Bob", 30), new Person("Charlie", 40));
long result = list.stream().collect(Collectors.reducing(0L, p -> (long) p.getAge(), (x, y) -> x + y));
System.out.println(result * result);
输出结果为：

4900

可以看到，在此示例中，首先创建了一个包含三个 Person 对象的列表。然后通过 stream 方法创建一个流，并使用 Collectors.reducing(0L, p -> (long) p.getAge(), (x, y) -> x + y) 将流中的元素通过类型转换函数和加法操作进行归约，起始值为 0。最终得到 70 这个 long 类型整数，计算其平方得到 4900，并输出。

需要注意的是，由于 identity 参数是类型为 U 的泛型参数，因此我们需要根据实际情况合理选择其类型，以避免类型转换错误或精度丢失。

总之，reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op) 是一种非常方便的收集器，它可以通过指定的类型转换函数和二元操作符将流中的元素逐一合并起来，并指定一个起始值，实现归约操作。

映射

mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream)
mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) 是 Java 8 中 Collectors 类提供的一个工厂方法，用于将流中的元素通过指定的映射函数进行转换，并将转换后的结果收集到另一个收集器中。

具体来说，该方法接收两个参数，第一个参数是类型为 Function<? super T, ? extends U> 的 mapper，它将类型为 T 的元素转换成类型为 U 的元素。第二个参数是类型为 Collector<? super U, A, R> 的 downstream，它接收类型为 U 的元素，并将它们收集到类型为 R 的容器中。在收集过程中使用了类型为 A 的可变结果容器。

下面是 mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) 的一个使用示例：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
Map<Integer, List<String>> result = list.stream()
.collect(Collectors.groupingBy(String::length, Collectors.mapping(String::toUpperCase, Collectors.toList())));
System.out.println(result);
输出结果为：

{5=[APPLE, BANANA, CHERRY], 4=[DATE]}
可以看到，在此示例中，首先创建了一个包含四个字符串元素的列表。然后使用 stream 方法创建一个字符串流，并使用 Collectors.groupingBy(String::length, Collectors.mapping(String::toUpperCase, Collectors.toList())) 将流中的元素按照长度进行分组，并将每组元素转换成大写字母后收集到一个列表中。最终得到一个 Map<Integer, List<String>> 对象，它将每个长度对应的字符串列表映射到对应的键上。

需要注意的是，虽然 mapping() 方法可以根据指定的映射函数将流中的元素转换成指定类型的元素，但是在使用该方法时，也需要注意所使用的收集器的类型和参数，以确保能够完成需要的收集操作。

总之，mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) 是一种非常方便的收集器，它可以将流中的元素通过指定的映射函数进行转换，并将转换后的结果收集到另一个收集器中，实现复杂的收集操作。

数组

toArray()
Collectors.toArray() 是 Java 8 中 Collectors 类提供的一个工厂方法，它返回一个用于将流中的元素收集到数组中的收集器。

具体来说，该方法不接受任何参数，直接返回一个 Collector<T, A, T[]> 对象，其中 T 表示流中元素的类型，A 表示可变结果容器的类型，T[] 表示最终返回的数组类型。在将流中的元素收集成数组时，会根据流中元素数量和元素类型创建一个合适大小的数组，并将所有元素依次复制到该数组中。

下面是 Collectors.toArray() 的一个使用示例：

List<String> list = Arrays.asList("apple", "banana", "cherry");
String[] array = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(array));
输出结果为：

[apple, banana, cherry]
可以看到，在此示例中，首先创建了一个包含三个字符串元素的列表。然后使用 stream() 方法创建一个字符串流，并使用 toArray(String[]::new) 将流中的元素收集到一个新的 String 数组中。最终得到一个包含所有字符串元素的数组，并使用 Arrays.toString() 方法将其转换为字符串形式打印出来。

需要注意的是，由于 toArray() 方法的返回类型是确定的数组类型 T[]，因此需要根据实际情况选择合适的数组类型，并确保流中的元素能够正确地转换为该类型的数组元素。此外，在使用 toArray() 方法时也需要注意流是否为空，以避免出现空指针异常。

总之，Collectors.toArray() 是一种方便的收集器，它可以将流中的元素直接收集到一个数组中，并返回该数组。

自定义收集器

collect(Collector<? super T, A, R> collector)
collect(Collector<? super T, A, R> collector) 是 Java Stream API 中 Stream 接口提供的一个方法，用于将流中的元素按照自定义规则进行收集和归约操作。

该方法接受一个 Collector 对象作为参数，该对象是一组用于描述如何向可变结果容器 A 中累加流中元素并将其转换成最终结果 R 的操作。

具体来说，Collector 包含四个操作：supplier、accumulator、combiner 和 finisher。其中，supplier 用于创建一个新的可变容器，accumulator 用于将流中的元素累加到容器中，combiner 用于将多个容器合并成一个，finisher 用于将最终结果从容器中提取出来。这些操作可以使用 Collectors 类中提供的方法进行组合和封装，从而实现包括toList、toSet、toMap、joining等常见的数据收集操作。

下面是一个使用 collect(Collector<? super T, A, R> collector) 方法的示例：

List<String> list = Arrays.asList("apple", "banana", "cherry");
String result = list.stream().collect(Collectors.joining("-"));
System.out.println(result);
输出结果为：

apple-banana-cherry
在此示例中，首先创建了一个包含三个字符串元素的列表。然后使用 stream() 方法创建一个字符串流，并使用 Collectors.joining("-") 将流中的元素通过“-”连接成一个字符串。最终调用 collect() 方法将结果收集到字符串变量中，并使用 System.out.println() 打印出来。

需要注意的是，当我们使用 collect(Collector<? super T, A, R> collector) 方法时，必须确保 Collector 对象能够正确处理流中的元素，否则可能会出现类型转换异常、空指针异常等问题。

总之，collect(Collector<? super T, A, R> collector) 方法是 Stream API 中一种灵活强大的数据收集和归约操作，通过自定义 Collector 可以实现各种数据类型的转换、组合和处理。
————————————————
版权声明：本文为CSDN博主「Ascend1797」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Ascend1977/article/details/130967971