什么是最终操作？
当我们通过最终方法对流对象进行操作，说明stream流操作也完成，最后我们将对象汇总成一个结果（总数、对象、集合……）
方法
collect：将Stream中的元素汇总（转化）成一个结果，可以是Set、List、Map
reduce：归纳，可以计算总和
Matching：规矩自定义的规则判断元素的匹配情况，返回布尔类型
- allMatch：是否全部匹配
- anyMatch：任意一个匹配
- noneMatch：没有匹配
max&min：通过一定的比较规则，返回stream中最大元素和最小元素
count：返回stream中元素的总个数
forEach：循环
实战说明
一、前提条件
Person类
package com.example; import lombok.AllArgsConstructor; import lombok.Data; import org.springframework.context.annotation.Configuration; import java.util.Objects; /** * @BelongsProject: StreamOperate * @BelongsPackage: com.example * @CreateTime: 2023-05-01 11:18 * @Description: Person实体类 * @Version: 1.0 */ public class Person implements Comparable<Person>{ public String getName() { return name; } public Person setName(String name) { this.name = name; return this; } public int getAge() { return age; } public Person setAge(int age) { this.age = age; return this; } public int getScore() { return score; } public Person setScore(int score) { this.score = score; return this; } private String name; private int age; private int score; public Person(String name, int age, int score) { this.name = name; this.age = age; this.score = score; } public Person() { } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", score=" + score + '}'; } @Override public boolean equals(Object o) { //地址相同，为true if (this == o) return true; //为null，并且类型不一样，为false if (o == null || getClass() != o.getClass()) return false; //向下转型，再去比较属性值 Person person = (Person) o; //如果属性值相同，最后的结果为true return age == person.age && score == person.score && Objects.equals(name, person.name); //return false; } @Override public int hashCode() { return Objects.hash(name, age, score); } @Override public int compareTo(Person o) { return this.getScore()-o.getScore(); } }
Data类
package com.example; import org.springframework.context.annotation.Configuration; import java.util.ArrayList; /** * @BelongsProject: StreamOperate * @BelongsPackage: com.example * @CreateTime: 2023-05-01 11:08 * @Description: Data类 * @Version: 1.0 */ public class Data { public static ArrayList<Person> getData() { ArrayList<Person> personList = new ArrayList<>(); personList.add(new Person("张三", 18, 90)); personList.add(new Person("李四", 19, 100)); personList.add(new Person("王五", 17, 60)); personList.add(new Person("赵六", 18, 89)); personList.add(new Person("孙七", 20, 96)); personList.add(new Person("郑十", 20, 46)); personList.add(new Person("周八", 20, 96)); personList.add(new Person("吴九", 20, 45)); personList.add(new Person("邓十一", 20, 35)); personList.add(new Person("刘十二", 20, 99)); personList.add(new Person("小十三", 20, 56)); return personList; } }
二、操作
collect：将Stream中的元素汇总（转化）成一个结果，可以是Set、List、Map
/** * @Description:最终操作——collection方法 * @Date: 2023/5/1 11:32 * @return: void **/ public void test() { Stream<Person> stream = Data.getData().stream(); //转化为List集合 List<Person> list = stream.collect(Collectors.toList()); //转化成Set集合 Set<Person> set = stream.collect(Collectors.toSet()); //转化成Map集合 Map<String, Integer> maps = stream.collect(Collectors.toMap(Person::getName, Person::getScore)); //输出结果 System.out.println(list); System.out.println("--------------------------------------------------------------------------"); System.out.println(set); System.out.println("--------------------------------------------------------------------------"); System.out.println(maps); }
输出结果:
reduce：归纳，可以计算总和
实例一、计算1-10的和
//声明一个stream对象 Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); //累加计算和 Optional<Integer> ret = stream1.reduce((n1, n2) -> n1 + n2); //输出结果 System.out.println(ret.get());
输出结果:
实例二、计算所有学生的总成绩
//获取数据源 Stream<Person> stream = Data.getData().stream(); //计算总成绩 Optional<Person> reduce = stream.reduce((n1, n2) -> new Person().setScore(n1.getScore() + n2.getScore())); //输出总成绩 System.out.println(reduce.get().getScore()); 通过实例我们会发现每次执行reduce都会产生很多临时对象，这样是很损耗性能的,我们可以通过实例化一个对象固定，这样就不会实例化很多临时对象. //实例化一个临时对希望 Person tmp = new Person(); //计算总成绩 Optional<Person> reduce1 = stream.reduce((n1, n2) -> tmp.setScore(n1.getScore() + n2.getScore())); //输出总成绩 System.out.println(reduce1.get().getScore());
输出结果:
Matching：规矩自定义的规则判断元素的匹配情况，返回布尔类型
- allMatch：是否全部匹配
- anyMatch：任意一个匹配
- noneMatch：没有匹配
//获取数据源 Stream<Person> stream = Data.getData().stream(); //判断集合中是否包含成绩大于80的人员 boolean result1 = stream.allMatch(ele -> ele.getScore() > 80); System.out.println("allMatch:"+result1); //判断集合中是否所有的成员成绩都及格 boolean result2 = stream.anyMatch(ele -> ele.getScore() >= 60); System.out.println("anyMatch:"+result2); //判断集合中是否所有的成员成绩都及格 boolean result3 = stream.noneMatch(ele -> ele.getScore() <= 60); System.out.println("noneMatch:"+result3);
输出结果:
max&min：通过一定的比较规则，返回stream中最大元素和最小元素
//找出成绩最高的对象 Optional<Person> max = Data.getData().stream().max((ele1, ele2) -> ele1.getScore() - ele2.getScore()); System.out.println(max); //找出成绩最低的对象 Optional<Person> min = Data.getData().stream().min((ele1, ele2) -> ele1.getScore() - ele2.getScore()); System.out.println(min);
输出结果:
count：返回stream中元素的总个数
//获取数据源 Stream<Person> stream = Data.getData().stream(); //返回总个数 long count = stream.count(); //输出结果 System.out.println(count);
输出结果:
forEach：循环
//获取数据源 Stream<Person> stream = Data.getData().stream(); //循环输出集合对象 stream.forEach(System.out::println);
输出结果:
