【Java8新特性】四、强大的Stream api

这里写自定义目录标题

一、了解Stream
二、流(stream)到底是什么？
三、Stream操作的三个步骤
四、创建Stream的四种方式
五、Stream 的中间操作
- 1、筛选和切片
- 2、map 映射
- 3、排序
六、Stream 的终止操作
- 1、查找和匹配
- 2、归约
- 3、收集

一、了解Stream

Stream是Java8中处理集合的一个工具

二、流(stream)到底是什么？

流是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列

【注意】
①、Stream 自己不会存储元素
②、Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
③、Stream操作是延迟执行的。这意味着它们会等到需要结果的时候才执行

三、Stream操作的三个步骤

创建Stream
一个数据源(如：集合，数组)，获取一个流

2)中间操作
一个中间操作链，对数据源的数据进行处理

3)终止操作
一个终止操作，执行中间操作链，并产生结果
在这里插入图片描述

四、创建Stream的四种方式

1、可以通过Collection系列集合提供的stream()或 parallelStram() 创建流

  List<String> list = new ArrayList<>();Stream<String> stream1 = list.stream();

2、通过Arrays中的静态方法stream()来获取数组流

  Employee[] emps = new Employee[10];Stream<Employee> stream2 = Arrays.stream(emps);

3、通过Stream中的静态方法 of() 创建流

 Stream<String> stream3 =  Stream.of("aa","bb","cc");

4、由函数创建流：创建无限流

Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
stream4.limit(10).forEach(System.out::println);Stream<Double> s = Stream.generate(() -> Math.random());
s.limit(10).forEach(System.out::println);

五、Stream 的中间操作

【注意】多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的
处理！，而是在终止操作时一次性处理，称为“惰性求值”

1、筛选和切片

filter - 接受Lambda，从流中排除某些元素
limit - 截断流，使其元素不超过给定数量
skip - 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n，则返回一个空流。
distinct - 筛选，通过流所生成元素的hashCode()和equals()去除重复元素

public class TestStream2 {List<Employee> employees = Arrays.asList(new Employee("张三",18,3000),new Employee("李四",45,4000),new Employee("王五",37,3000),new Employee("赵六",18,6000),new Employee("田七",40,10000),new Employee("田七",40,10000));//filter//内部迭代：迭代操作由Stream API完成@Testpublic void test1(){//中间操作不会不会有任何结果Stream<Employee> sm = employees.stream().filter((e) -> e.getAge() > 25);//终止操作//sm.forEach((e) -> System.out.println(e));sm.forEach(System.out::println);}//limit@Testpublic void test2(){employees.stream().filter((e) -> e.getAge() > 25).limit(2).forEach(System.out::println);}//skip@Testpublic void test3(){employees.stream().filter((e) -> e.getAge() > 25).skip(2).forEach(System.out::println);}//distinct() 【注意】比较的元素需要equals()方法@Testpublic void test4(){employees.stream().filter((e) -> e.getAge() > 25).skip(2).distinct().forEach(System.out::println);}
}

2、map 映射

map：接收一个函数作为参数，该函数会被用到每个元素上，并将其映射成一个新的元素
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

@Testpublic void test5(){List<String> list = Arrays.asList("aaa","bb","ccc");list.stream().map((str) -> str.toUpperCase()).forEach(System.out::println);System.out.println("-----------------------------------");employees.stream().map(Employee::getName).forEach(System.out::println);System.out.println("------------------------------------");Stream<Stream<Character>> sm = list.stream().map(TestStream2::filterCharacter);sm.forEach((stm) -> stm.forEach(System.out::println));System.out.println("------------------------------------");System.out.println("上述代码优化");list.stream().flatMap(TestStream2::filterCharacter).forEach(System.out::println);}//方法：将字符串转换成一个流
public static Stream<Character> filterCharacter(String str){List<Character> list = new ArrayList<>();for(Character c: str.toCharArray()){list.add(c);}return list.stream();
}

3、排序

sorted() : 自然排序
sorted(Comparator com) ：定制排序

 @Testpublic void test6(){List<String> list = Arrays.asList("aaa","bb","ccc");list.stream().sorted().forEach(System.out::println);System.out.println("------------------------------------");list.stream().sorted((x,y) -> -x.compareTo(y)).forEach(System.out::println);}

六、Stream 的终止操作

1、查找和匹配

allMatch - 检查是否匹配所有元素
anyMatch - 检查是否至少匹配一个元素
noneMatch - 检查是否没有匹配所有元素
findFirst - 返回第一个元素
FindAny - 返回当前流中的任意元素
count - 返回当前流中元素的总个数
max - 返回流中的最大值
min - 返回流中的最小值

public class TestStream3 {List<Employee> employees = Arrays.asList(new Employee("张三",18,3000, Employee.Status.Free),new Employee("李四",45,4000, Employee.Status.Free),new Employee("王五",37,3000, Employee.Status.Busy),new Employee("赵六",18,6000, Employee.Status.Vocation),new Employee("田七",40,10000, Employee.Status.Vocation));/*查找与匹配allMatch - 检查是否匹配所有元素anyMatch - 检查是否至少匹配一个元素noneMatch - 检查是否没有匹配所有元素findFirst - 返回第一个元素FindAny - 返回当前流中的任意元素count - 返回当前流中元素的总个数max - 返回流中的最大值min - 返回流中的最小值*/@Testpublic void test(){//allMatchboolean b = employees.stream().allMatch((e) -> e.getStatus().equals(Employee.Status.Busy));System.out.println(b);//anyMatchSystem.out.println(employees.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.Busy)));//findFirst//Optional: 容器类Optional<Employee> op = employees.stream().sorted((x, y) -> -Double.compare(x.getSalary(), y.getSalary())).findFirst();op.orElse(new Employee());  // orElse: 如果为空，则用什么来代替Employee e = op.get();System.out.println(e);}@Testpublic void test1(){long count = employees.stream().count();System.out.println(count);Optional<Employee> max = employees.stream().max((x, y) -> -Double.compare(x.getSalary(), y.getSalary()));System.out.println(max.get());//最少的工资是多少Optional<Double> min = employees.stream().map(Employee::getSalary).min(Double::compare);System.out.println(min.get());}
}

2、归约

reduce(T identity,BinaryOperater) / reduce(BinaryOperater)：可以将流中元素反复结合起来，得到一个值。返回 T

public void test(){List<Integer> list = Arrays.asList(1,2,3,4,5);//0称之为起始元素，将0作为x，在流中取出一个元素作为y,//然后将相加的结果作为x,再从流中取出一个元素作为y相加...//一直到流中的元素全部加完Integer sum = list.stream().reduce(0, (x, y) -> x + y);System.out.println(sum);System.out.println("------------------------------");//获取当前公司中，工资的总和Double sumSalary = employees.stream().map(Employee::getSalary).reduce(0d, (x, y) -> x + y);System.out.println(sumSalary);}

3、收集

collect(Collector c)
collect - 将流转换成其他形式，接受一个Collector接口的实现，
用于给stream中元素做汇总的方
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List，Set，Map)
但是Collectors实用类提供了很多静态方法，可以方便地创建常用收集器实例，具体方法和实例如下demo：

/*** @author houChen* @date 2021/1/1 9:32* @Description:*** 收集* collect - 将流转换成其他形式，接受一个Collector接口的实现，* 用于给stream中元素做汇总的方法*/
public class TestStream4 {List<Employee> employees = Arrays.asList(new Employee("张三",18,3000, Employee.Status.Free),new Employee("李四",45,4000, Employee.Status.Free),new Employee("王五",37,3000, Employee.Status.Busy),new Employee("赵六",18,6000, Employee.Status.Vocation),new Employee("田七",40,10000, Employee.Status.Vocation));@Testpublic void test2(){List<String> names = employees.stream().map(Employee::getName).collect(Collectors.toList());for (String name: names) {System.out.println(name);}System.out.println("-------------------------------------------");//将结果收集到特殊的集合中HashSet<String> set = employees.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));set.forEach(System.out::println);}@Testpublic void test3(){//总数Long count = employees.stream().collect(Collectors.counting());System.out.println(count);System.out.println("---------------------------------");//求平均年龄Double avgAge = employees.stream().collect(Collectors.averagingDouble(Employee::getAge));System.out.println(avgAge);System.out.println("---------------------------------");//总和Double sumSalary = employees.stream().collect(Collectors.summingDouble(Employee::getSalary));System.out.println(sumSalary);//最大值Optional<Employee> maxSalary = employees.stream().collect(Collectors.maxBy((x, y) -> Double.compare(x.getSalary(), y.getSalary())));System.out.println(maxSalary.get());}//分组@Testpublic void test4(){Map<Employee.Status, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(Employee::getStatus));Set<Employee.Status> statuses = map.keySet();Iterator<Employee.Status> iterator = statuses.iterator();while (iterator.hasNext()){Employee.Status next = iterator.next();System.out.println(next+":"+map.get(next));}}//多级分组 : 先按照状态分组，再按照青年、老年分组@Testpublic void test5(){Map<Employee.Status, Map<String, List<Employee>>> maps = employees.stream().collect(Collectors.groupingBy(Employee::getStatus,Collectors.groupingBy((e) -> {if (((Employee) e).getAge() <= 35) {return "青年";} else {return "老年";}})));System.out.println(maps);}//分区://   满足条件的为一个区//   不满足条件的为一个区@Testpublic void test6(){Map<Boolean, List<Employee>> map = employees.stream().collect(Collectors.partitioningBy(e -> e.getSalary() > 8000));System.out.println(map);}//将员工所有的名字取出来，并用"," 分隔@Testpublic void test7(){String namestr = employees.stream().map(Employee::getName).collect(Collectors.joining(","));System.out.println(namestr);}
}