Collectors.groupingBy方法的使用

简单使用

业务场景：现在有5个人，这些人都年龄分部在18-30岁之间。现要求把他们按照年龄进行分组
key：年龄
value：数据列表

package com.liudashuai;import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class Test{public static void main(String[] args) {People people1 = new People("张三", 19);People people2 = new People("李四", 19);People people3 = new People("王五", 27);People people4 = new People("赵六", 37);People people5 = new People("刘备", 37);List<People> list = Arrays.asList(people1, people2, people3, people4, people5);//按照age进行分组Map<Integer, List<People>> result = list.stream().collect(Collectors.groupingBy(People::getAge));//打印结果result.forEach((k, v) -> {System.out.println(k);System.out.println(v);System.out.println("--------------------");});}
}
class People{public String name;public int age;public People() {}public People(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "People{" +"name='" + name + '\'' +", age=" + age +'}';}
}

输出结果如下：

在这里插入图片描述

效果相当于是，把list这个集合里面存放的100个人每个人都调用Perple的getAge方法，按照getAge方法的返回值进行分组。每个组是一个Map<Integer, List>类型的对象。每个组，即Map<Integer, List>，这个对象中的键是getAge的返回值，即，分组的依据。Map<Integer, List>的值是这个年龄对应组中的成员列表，是一个list。

分组且排序

分组之后，是不能对每个分组进行比较的（也就无法排序），因为groupingBy方法的返回值是放在collect方法里面作为参数的，执行完后已经是终止了流。

Stream流中的collect方法长这样：

public interface Stream<T> extends BaseStream<T, Stream<T>> {……<R, A> R collect(Collector<? super T, A, R> collector);……
}

collect方法能将流转换成其他的形式，他需要接收一个Collector接口的实现，用于给Stream中元素做汇总方法，即告诉程序怎么汇总。

collect中的参数一般我们都是写java.util.stream.Collectors类中内置的静态方法。比如，Collectors.toList()汇总成List、Collectors.toSet()汇总成Set、Collectors.toMap(……)汇总为Map、Collectors.counting()汇总为个数、Collectors.groupingBy(……)按照某个东西进行汇总分组等等

collect，收集，可以说是stream流中内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合、收集为一个字符串等等。

Collectors中的groupingBy方法声明如下：

Collectors.groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)

好，然后我们去完成需求。

做法：

提前排序，再进行分组.

这里还展示了一些groupingBy方法的扩展用法。

package com.liudashuai;import java.util.*;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {Student student1 = new Student(1, 10);Student student2 = new Student(1, 10);Student student3 = new Student(2, 20);Student student4 = new Student(2, 30);Student student5 = new Student(3, 30);Student student6 = new Student(3, 40);Student student7 = new Student(4, 100);Student student8 = new Student(4, 100);Student student9 = new Student(4, 20);Student student10 = new Student(4, 10);List<Student> list = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9, student10);System.out.println("--------- 根据id字段分组，求每个分组的分数总和 ----------");Map<Integer, Integer> collect = list.stream().collect(Collectors.groupingBy(Student::getId, Collectors.summingInt(Student::getScore)));System.out.println(collect.toString());System.out.println("--------- 根据id字段分组，求每个分组的学生数量 ----------");Map<Integer, Long> countMap = list.stream().collect(Collectors.groupingBy(Student::getId, Collectors.counting()));System.out.println(countMap.toString());System.out.println("--------- 根据分数字段分组,默认分组 ----------");Map<Integer, List<Student>> defaultGroupMap = list.stream().collect(Collectors.groupingBy(Student::getScore));
//        System.out.println(JSONObject.toJSONString(defaultGroupMap));System.out.println(defaultGroupMap);System.out.println("--------- 根据id字段分组,默认分组(可以看到同组的分数不一定从低到高) ----------");//注意：你collect(Collectors.groupingBy(Student::getId))和collect(Collectors.groupingBy(Student::getId),Collector.toList())效果是一样的，因为一个参数的groupingBy方法底层默认是用Collector.toList()作为值收集器的。当然带参的groupingBy方法不是默认用Collector.toList()作为值收集器的，是你自己指定的。比如上面“根据id字段分组，求每个分组的学生数量”案例里面我们就自己指定值收集器为Collectors.counting()，这样数据会被收集到一个Integer里面，然后放到Map中作为值。Map<Integer, List<Student>> defaultGroupMap2 = list.stream().collect(Collectors.groupingBy(Student::getId));
//        System.out.println(JSONObject.toJSONString(defaultGroupMap));System.out.println(defaultGroupMap2);System.out.println("--------- 先按分数进行升序排序，然后根据id字段分组(可以看到同组的分数是从低到高的) ----------");Map<Integer, List<Student>> sortGroupMap = list.stream().sorted(Comparator.comparing(Student::getScore)).collect(Collectors.groupingBy(Student::getId));
//        System.out.println(JSONObject.toJSONString(sortGroupMap));System.out.println(sortGroupMap);System.out.println("--------- 先降序排序，再根据id进行分组 ----------");Map<Integer, List<Student>> reversedSortGroupMap = list.stream().sorted(Comparator.comparing(Student::getScore).reversed()).collect(Collectors.groupingBy(Student::getId));
//        System.out.println(JSONObject.toJSONString(reversedSortGroupMap));System.out.println(reversedSortGroupMap);}
}class Student {public Student(Integer id, Integer score) {this.id = id;this.score = score;}private Integer id;private Integer score;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public Integer getScore() {return score;}public void setScore(Integer score) {this.score = score;}@Overridepublic String toString() {return "Student{" +"id=" + id +", score=" + score +'}';}
}

执行结果：

在这里插入图片描述

分组后再进行分组（一二级分组）

package com.liudashuai;import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Person> personList = new ArrayList<>();personList.add(new Person("Ram", 30,"浙江"));personList.add(new Person("Shyam", 25,"江苏"));personList.add(new Person("Shiv", 25,"江苏"));personList.add(new Person("Aim", 25,"浙江"));personList.add(new Person("Mahesh", 30,"江苏"));personList.add(new Person("Make", 30,"江苏"));// 将员工先按性别分组，再按地区分组Map<Integer, Map<String, List<Person>>> group = personList.stream().collect(Collectors.groupingBy(Person::getAge,Collectors.groupingBy(Person::getArea)));group.forEach((k,v)->{System.out.println("一级分组的依据是："+k);v.forEach((a,b)->{System.out.println("二级分组的依据是："+a+" 值是："+b);});});}
}class Person {private String name;private int age;private String area;public Person(String name, int age, String area) {this.name = name;this.age = age;this.area = area;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getArea() {return area;}public void setArea(String area) {this.area = area;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", area='" + area + '\'' +'}';}
}

结果如下：

在这里插入图片描述

补充一句：groupingBy分组是通过hashcode和equals方法来判断两个对象是否相等的，相等才会被放到一个组里。

因为String重写了equals和hashcode方法，所以按照字符串进行分组只要两个字符串内容是一样的，就算他们是两个不同的对象，那么也会被放到一个组里面。

按照int类型的值进行分组，会被自动装箱为Integer，因为Integer中的equals和hashcode方法也不重写了，所以，两个int值一样，也会被放到一个组里面。所以放心按照int和String来进行分组，不会出现内容一样，被分到两个组里面去的情况的。当然Double也一样，很多java提供的类型都重写了hashcode和equals方法。

而且java中有一个规范，就是equals判断相等的，那么hashcode的判断就要相等。所以我们不知道两个对象是否equals和hashcode的判断结果都是相等的，你就看两个对象进行equals判断是否相当于，如果equals判断相等，那么一般来说hashcode的判断也会相等的。除非你不遵守java的规范来写代码。

groupingBy分组指定键名

package com.liudashuai;import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Stream<Student> studentStream = Stream.of(new Student("赵丽颖", 52, 95),new Student("杨颖", 56, 88),new Student("貂蝉", 56, 88),new Student("迪丽热巴", 56, 55),new Student("柳岩", 52, 33));//多级分组//1.先根据年龄分组,然后再根据成绩分组，又按及格和不及格分组// 分析:// 第一个Collectors.groupingBy() 使用的是年龄分组// 第二个Collectors.groupingBy() 使用分数进行分组// 第三个Collectors.groupingBy() 使用及格和不及格进行分组Map<Integer, Map<Integer, Map<String, List<Student>>>> map = studentStream.collect(Collectors.groupingBy(str -> str.getAge(), Collectors.groupingBy(str -> str.getScore(), Collectors.groupingBy((student) -> {if (student.getScore() >= 60) {return "及格";} else {return "不及格";}}))));map.forEach((key,value)->{System.out.println("年龄:" + key);value.forEach((k2,v2)->{System.out.println("\t" + v2);});});}
}
class Student {private String name;private int age;private int score;public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}
}

在这里插入图片描述

之前我们用方法引用，相当于是借别人的方法来做groupingBy形参接口的方法实现来进行分组，这里我们自己写的就相当于是自己写groupingBy形参接口的方法实现来进行分组。他是怎么进行分组的呢？其实就是看这个实现的返回值是什么，然后根据返回值的equals和hashcode判断是否相等来进行分组的。所以，我们上面第二个分组groupingBy方法的return "及格"可以把”年龄一样，分数一样，且分数>60“的”杨颖“和”貂蝉“分为一组。

package com.liudashuai;import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Stream<Student> studentStream = Stream.of(new Student("赵丽颖", 52, 95),new Student("杨颖", 56, 88),new Student("杨颖", 56, 88),new Student("貂蝉", 56, 88),new Student("迪丽热巴", 56, 55),new Student("柳岩", 52, 33));//多级分组//1.先根据年龄分组,然后再根据成绩分组，又按及格和不及格分组// 分析:// 第一个Collectors.groupingBy() 使用的是年龄分组// 第二个Collectors.groupingBy() 使用分数进行分组// 第三个Collectors.groupingBy() 使用及格和不及格进行分组Map<Integer, Map<Integer, Map<String, List<Student>>>> map = studentStream.collect(Collectors.groupingBy(str -> str.getAge(), Collectors.groupingBy(str -> str.getScore(), Collectors.groupingBy((student) -> {if (student.getName().equals("杨颖")) {return "是杨颖";} else {return "不是杨颖";}}))));map.forEach((key,value)->{System.out.println("年龄:" + key);value.forEach((k2,v2)->{System.out.println("\t" + v2);});});}
}
class Student {private String name;private int age;private int score;public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}
}

在这里插入图片描述

上面这个例子里面，把”年龄一样，分数一样，名字是杨颖的分为一组“，”年龄一样，分数一样，名字不是杨颖的分为另一组“。

Collectors.mapping()方法的使用

package com.liudashuai;import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Person> list = new ArrayList<>();list.add(new Person("Ram", 30));list.add(new Person("Shyam", 20));list.add(new Person("Shiv", 20));list.add(new Person("Mahesh", 30));//Collectors.mapping(Person::getName, Collectors.joining(",", "[", "]"))相当于把stream流中的每个元素的getName返回值作为新Stream流中元素，然后进行拼接，元素与元素之间用逗号隔开，最前面用"["，最后面用"]"拼接。Collectors.mapping相当于是对流中的元素再继续进行一次操作形成一个流，然后如果有第二个参数会用第二个参数再对这个流进行汇总。String nameByAge = list.stream().collect(Collectors.mapping(Person::getName, Collectors.joining(",", "[", "]")));//下面这样写，不行，会报错，因为stream流中的每个元素执行getAge方法返回的元素不是一个字符串，所以后面不能直接用Collectors.joining来拼接。//String nameByAge2 = list.stream().collect(Collectors.mapping(Person::getAge, Collectors.joining(",", "[", "]")));System.out.println(nameByAge);//下面这样也行。相当于是collect(Collectors.joining(",", "[", "]"))把执行collect方法的流直接对流进行汇总拼接了。不像上面collect(Collectors.mapping(Person::getAge, Collectors.joining(",", "[", "]")))这样对调用collection方法的流汇总前还进行一次操作形成流，才汇总。nameByAge = list.stream().map(person -> person.getName()).collect(Collectors.joining(",", "[", "]"));System.out.println(nameByAge);}
}class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

执行结果：

在这里插入图片描述

Collectors的groupingBy和mapping一起用

package com.liudashuai;import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Person> list = new ArrayList<>();list.add(new Person("Ram", 30));list.add(new Person("Shyam", 20));list.add(new Person("Shiv", 20));list.add(new Person("Mahesh", 30));//按年龄进行分组形成多个流，一个分组一个流，然后把每个分组对应的stream流中的元素改造为那些元素执行getName的返回值得到多个新的Stream流（一个分组一个新的流），并且把这多个新的Stream流进行拼接，元素与元素之间用逗号隔开，最前面用"["最后面用"]"拼接，然后返回，放在一个Map<Integer, String>里中一个键值对的里，作为值，这个键值对的键是分组的依据，即那个getName。Map<Integer, String> nameByAgeMap = list.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.joining(",", "[", "]"))));//输出Map数据nameByAgeMap.forEach((k, v) -> System.out.println("Age:" + k + "  Persons: " + v));}
}class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

结果：

在这里插入图片描述

Collectors的toList/toSet/toMap

package com.liudashuai;import java.util.*;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());System.out.println("===========");listNew.forEach(System.out::println);Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());System.out.println("===========");set.forEach(System.out::println);List<Person> personList = new ArrayList<>();personList.add(new Person("Ram", 30));personList.add(new Person("Shyam", 20));personList.add(new Person("Shiv", 20));personList.add(new Person("Mahesh", 30));//相当于是toMap的第一个参数是返回的Map的键，执行collect方法的stream流对象中的每个元素(p -> p中前面的p就是指执行collect方法的stream流对象中的每个元素，后面的p是指返回到Map中的值)为返回的Map的值Map<String, Person> collect = personList.stream().collect(Collectors.toMap(Person::getName, p -> p));System.out.println("===========");collect.forEach((k, v) -> System.out.println("键:" + k + "  值: " + v));}
}class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

执行结果：

在这里插入图片描述

Collectors的partitioningBy

package com.liudashuai;import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Person> personList = new ArrayList<>();personList.add(new Person("Ram", 33));personList.add(new Person("Shyam", 25));personList.add(new Person("Shiv", 20));personList.add(new Person("Mahesh", 30));//按年龄进行分区，大于25的在一个区，不大于25的在一个区Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getAge() > 25));part.forEach((k, v) -> System.out.println("键:" + k + "  值: " + v));}
}class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

在这里插入图片描述

Collectors的joining

package com.liudashuai;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Person> personList = new ArrayList<>();personList.add(new Person("Ram", 33));personList.add(new Person("Shyam", 25));personList.add(new Person("Shiv", 20));personList.add(new Person("Mahesh", 30));// 可以写一个分隔符String collect = personList.stream().map(Person::getName).collect(Collectors.joining(" "));System.out.println("所有员工的姓名（中间用空格隔开）:"+collect);//可以写前缀、后缀、分隔符都写List<String> list = Arrays.asList("A", "B", "C");String string = list.stream().collect(Collectors.joining("+","#","@"));System.out.println("拼接后的字符串：" + string);}
}class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

在这里插入图片描述

Collectors的reducing

reducing的重载有三个：

一个参数的

javapublic static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)

参数说明：

BinaryOperator op 归集操作函数输入参数T返回T

例子：我们这里实现一个简单的求和功能

package com.liudashuai;import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Integer> testData = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);Optional<Integer> sum = testData.stream().collect(Collectors.reducing((prev, cur) -> {System.out.println("前一个值=>" + prev + " 当前值=>" + cur);return prev + cur;}));System.out.print(sum.get()); // 45}
}

效果：

在这里插入图片描述

两个参数的

public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op)

参数说明：

T identity 返回类型T初始值
BinaryOperator op 归集操作函数输入参数T返回T

例子：我们这里实现一个简单的求和且加上20的功能

package com.liudashuai;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Integer> testData = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);Integer sum = testData.stream().collect(Collectors.reducing(20, (prev, cur) -> {System.out.println("前一个值=>" + prev + " 当前值=>" + cur);return prev + cur;}));System.out.print(sum); //65}
}

效果（看到初始值为20，这里执行了9次reducing方法）：

在这里插入图片描述

三个参数的

public static <T, U> Collector<T, ?, U> reducing(U identity,Function<? super T, ? extends U> mapper,BinaryOperator<U> op)

这个函数才是真正体现reducing(归集)的过程。调用者要明确知道以下三个点：

需要转换类型的初始值
类型如何转换
如何收集返回值

参数说明：

U identity 最终返回类型U初始值
Function<? super T, ? extends U> mapper 将输入参数T转换成返回类型U的函数
BinaryOperator op 归集操作函数输入参数U返回U

例子：我们这里实现一个简单数字转字符串并按逗号进行拼接的功能

package com.liudashuai;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {List<Integer> testData = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);String joinStr = testData.stream().collect(Collectors.reducing("转换成字符串", in -> {return in + "";}, (perv, cur) -> {return perv + "," + cur;}));System.out.print(joinStr); // 转换成字符串,1,2,3,4,5,6,7,8,9}
}

效果：

在这里插入图片描述

reducing和reduce的区别

Stream流有一个reduce方法，Stream流的collect方法的参数还有一个常用的Collectors.reducing方法。他们的效果都差不多。reduce是减少的意思，此处意为聚合，即聚拢、合并的意思。

他们效果差不多，那么他们有什么区别呢？

下面我们来看看两个方法的区别吧。

只有一个参数的reducing和reduce方法的区别。一个参数的Collectors.reducing(Integer::sum)或者reduce(Integer::sum)返回的都是一个Optional对象。因为reducing或者reduce的结果可能是null。Optional是一个可以为null的容器对象，它的主要作用就是为了避免Null检查，防止NullpointerException，如果Stream的reduce或者reducing方法不是返回一个Optional对象，那么聚合的时候，就可能出现空指针异常，所以，这里java设计reduce或者reducing方法返回一个Optional对象。

package com.liudashuai;import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Optional<Integer> sumOpt = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(Integer::sum));System.out.println(sumOpt);     // 打印：Optional[45]sumOpt = Stream.iterate(0, i -> ++i).limit(10).reduce(Integer::sum);System.out.println(sumOpt);     // 打印：Optional[45]}
}

在这里插入图片描述

比如：

package com.liudashuai;import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Optional<Integer> sumOpt = Stream.iterate(0, i -> ++i).limit(0).collect(Collectors.reducing(Integer::sum));System.out.println(sumOpt);     // 打印：Optional[45]sumOpt = Stream.iterate(0, i -> ++i).limit(0).reduce(Integer::sum);System.out.println(sumOpt);     // 打印：Optional[45]}
}

在这里插入图片描述

如果要获取Optional中的reduce或者reducing的结果。

我们可以这样：

package com.liudashuai;import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Optional<Integer> sumOpt = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(Integer::sum));System.out.println(sumOpt.get());sumOpt = Stream.iterate(0, i -> ++i).limit(10).reduce(Integer::sum);System.out.println(sumOpt.get());}
}

在这里插入图片描述

两个参数的reducing和reduce方法的区别，效果都是默认值+累加后的结果

package com.liudashuai;import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Integer sum = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(10, Integer::sum));System.out.println(sum);        // 55sum = Stream.iterate(0, i -> ++i).limit(10).reduce(10, Integer::sum);System.out.println(sum);        // 55}
}

在这里插入图片描述

这里两个参数的reducing和reduce方法，因为有初始值，所以，结果不会是空值，所以java设计reducing和reduce两个参数的方法的时候就没有设计返回Optional了。

package com.liudashuai;import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Integer sum = Stream.iterate(0, i -> ++i).limit(0).collect(Collectors.reducing(99, Integer::sum));System.out.println(sum);sum = Stream.iterate(0, i -> ++i).limit(0).reduce(22, Integer::sum);System.out.println(sum);  }
}

在这里插入图片描述

前面两种方式效果都是一样的。reducing和reduce方法的不同点在与三个参数的这个方法。

下面是三个参数的。第一个参数还是默认值，第二个参数和第三个参数就有区别了。

package com.liudashuai;import java.math.BigDecimal;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {BigDecimal sumDecimal = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(BigDecimal.ZERO, BigDecimal::new, BigDecimal::add));System.out.println(sumDecimal); // 45sumDecimal = Stream.iterate(0, i -> ++i).limit(10).reduce(BigDecimal.ZERO, (d, i) -> d.add(new BigDecimal(i)), BigDecimal::add);System.out.println(sumDecimal); // 45}
}

在这里插入图片描述

可以看出我们的Collectors.reducing第二个参数是一个Function<Integer,BigDecimal>。这里第二个参数的对象不是进行聚合运算的，而是进行了一个转换的。第三个参数才是我们的累加操作。

Stream#reduce中，第二个参数是一个BiFunction<BigDecimal, Integer, BigDecimal>。第二个参数的对象是用来进行汇总操作的。其中，d表示上一个累加的结果。i表示要当前这轮遍历要进行累加的数。第三个参数是个BinaryOperator<BigDecimal>类型的对象，只在并行流场景下会用到，这里不展开讲，总之就是说，我们在串行流中哪怕将Stream#reduce的第三个参数，改为任意的语句，他都是不影响执行的。

package com.liudashuai;import java.math.BigDecimal;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {BigDecimal sumDecimal = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(BigDecimal.ZERO, BigDecimal::new, BigDecimal::add));System.out.println(sumDecimal); // 45sumDecimal = Stream.iterate(0, i -> ++i).limit(10).reduce(BigDecimal.ZERO, (d, i) -> {System.out.println(d+" "+i);return d.add(new BigDecimal(i));}, BigDecimal::add);System.out.println(sumDecimal); // 45}
}

在这里插入图片描述

这里我试一下Stream#reduce中的第三个参数。看看到底有没有影响结果。

我们在串行流中哪怕将Stream#reduce的第三个参数，改为任意操作，他都是不影响结果执行的，例如我们这里取最大值：

package com.liudashuai;import java.math.BigDecimal;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {BigDecimal sumDecimal = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(BigDecimal.ZERO, BigDecimal::new, BinaryOperator.maxBy(BigDecimal::compareTo)));System.out.println(sumDecimal); // 9sumDecimal = Stream.iterate(0, i -> ++i).limit(10).reduce(BigDecimal.ZERO, (d, i) -> d.add(new BigDecimal(i)), BinaryOperator.maxBy(BigDecimal::compareTo));System.out.println(sumDecimal); // 45}
}

结果：

在这里插入图片描述

哪怕我们改为null也是不会影响Stream#reduce的执行结果的：

package com.liudashuai;import java.math.BigDecimal;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {BigDecimal sumDecimal = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing(BigDecimal.ZERO, BigDecimal::new, (l, r) -> null));System.out.println(sumDecimal); // nullsumDecimal = Stream.iterate(0, i -> ++i).limit(10).reduce(BigDecimal.ZERO, (d, i) -> d.add(new BigDecimal(i)), (l, r) -> null);System.out.println(sumDecimal); // 45}
}

在这里插入图片描述

当然哈，这里并没有要求reducing和reduce的几个参数一定要和BigDecimal有关哈。比如下面这样也行的：

package com.liudashuai;import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {String s = Stream.iterate(0, i -> ++i).limit(10).collect(Collectors.reducing("测试",in -> {return Integer.toString(in);}, (perv, cur) -> {return perv + "," + cur;}));System.out.println(s);s = Stream.iterate(0, i -> ++i).limit(10).reduce("测试", (d, i) -> d + "," + i, (l, r) -> null);System.out.println(s);}
}

在这里插入图片描述

注意：这里不好直接用Integer::toString，因为Integer中的多个toString都可能会匹配到Integer::toString，方法引用表达式Integer::toString可以表示引用Integer类的toString静态方法Functionf=t->Integer.toString(t)也可以表示引用任意Integer实例的toString成员方法Functionf=t->t.toString()编译器无法判断应该使用哪个解释。具体可以看https://www.imooc.com/article/22608。

在这里插入图片描述

当然哈，Object::toString可以，因为Object中没有多个可能和Object::toString这个方法引用匹配的方法。

在这里插入图片描述

结果：

在这里插入图片描述

Collectors的toCollection

Collectors.toCollection(Supplier<C> collectionFactory) 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到指定类型的集合中的方法。

该方法接受一个参数，即一个类型为 Supplier<C> 的函数式接口，其中 C 是要创建的集合类型。例如，如果我们想要创建一个 LinkedList 集合，可以这样使用该方法：

List<Integer> list = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toCollection(LinkedList::new));

在上述示例中，我们使用 Collectors.toCollection() 方法，并传入一个 LinkedList::new 函数，表示创建一个 LinkedList 类型的集合对象。然后把流中的数据都放到这个LinkedList对象里面去。

使用Collectors的toCollection的好处是，比较灵活，我们可以随便指定把流放到某个类型的集合里面。你看，如果使用的是Collectors.toList()方法就只能把流中的数据放到List里面去，不能用这个toList方法把流中的数据放到Set或者某个Map里面去。

例子1：

package com.liudashuai;import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {List<Integer> numbers = Stream.of(1,2,3,4,5).collect(Collectors.toCollection(ArrayList::new));numbers.forEach(System.out::println);}
}

在这里插入图片描述

例子2：

package com.liudashuai;import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {Stream<String> stream = Stream.of("20", "50", "80", "100", "130", "150", "200");TreeSet collection = stream.collect(Collectors.toCollection(TreeSet::new));System.out.println("Collection = "+collection);}
}

在这里插入图片描述

例子3：

package com.liudashuai;import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.TreeSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {//直接创建treeSet数据 [1, 3, 4]TreeSet<Integer> collect3= Stream.of(1, 3, 4).collect(Collectors.toCollection(TreeSet::new));System.out.println(collect3.toString());List<String> list = Arrays.asList("java", "python", "C++","php","java");//用LinkedList收集List<String> linkedListResult = list.stream().collect(Collectors.toCollection(LinkedList::new));linkedListResult.forEach(System.out::println);System.out.println("--------------");//用CopyOnWriteArrayList收集List<String> copyOnWriteArrayListResult = list.stream().collect(Collectors.toCollection(CopyOnWriteArrayList::new));copyOnWriteArrayListResult.forEach(System.out::println);System.out.println("--------------");//用TreeSet收集TreeSet<String> treeSetResult = list.stream().collect(Collectors.toCollection(TreeSet::new));treeSetResult.forEach(System.out::println);}
}

在这里插入图片描述

toCollection和groupingBy一起用

package com.liudashuai;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {Student student1 = new Student(1, 10);Student student2 = new Student(1, 10);Student student3 = new Student(2, 20);Student student4 = new Student(2, 30);Student student5 = new Student(3, 30);Student student6 = new Student(3, 40);Student student7 = new Student(4, 100);Student student8 = new Student(4, 100);Student student9 = new Student(4, 20);Student student10 = new Student(4, 10);List<Student> list = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9, student10);//按照id进行分组，然后让每个元素执行getScore方法变为一个新的流。然后放到一个ArrayList中给返回。作为一个Map<Integer, List<Integer>>的一个键值对对象中的值，分组的那个依据作为键（即，getScore方法返回的值作为键）。Map<Integer, List<Integer>> groupMap = list.stream().collect(Collectors.groupingBy(Student::getId, Collectors.mapping(Student::getScore, Collectors.toCollection(ArrayList::new))));System.out.println(groupMap.toString());}
}
class Student {private Integer id;private Integer score;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public Integer getScore() {return score;}public void setScore(Integer score) {this.score = score;}public Student(Integer id, Integer score) {this.id = id;this.score = score;}
}