java8-强大的Stream API
学习使我快乐，我要去上海的字节跳动，梦想是要有的，万一一不小心实现了呢！！！
1、了解Stream
Java8中有两个最为重要的改变。第一个是Lambda表达式，另外一个则是Stream API(java.util.stream.*)
Stream是Java8中处理集合的关键抽象概念，对集合进行的操作，可以指定非常复杂的
查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行数据库查询。
也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式
【注意】产生一个新流，原来的数据源没有任何改变
2、流（stream）到底是什么？
流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
“集合讲的是数据，流讲的是计算”
【注意】
①、Stream 自己不会存储元素
②、Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
③、Stream操作是延迟执行的。这意味着它们会等到需要结果的时候才执行
3、Stream操作的三个步骤
1）创建Stream
一个数据源（如：集合，数组），获取一个流
2）中间操作
一个中间操作链，对数据源的数据进行处理
3）终止操作
一个终止操作，执行中间操作链，并产生结果
4、创建Stream的四种方式
public class TestStream1 { //创建Stream @Test public void test1(){ //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、创建无限流 //迭代 第一个参数：种子 第二个参数：funtion的函数式接口 Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2); stream4.limit(10).forEach(System.out::println); System.out.println("---------------------------------"); //生产 Stream<Double> s = Stream.generate(() -> Math.random()); s.limit(10).forEach(System.out::println); } }
5、Stream 筛选和切片
【注意】多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的
处理！，而是在终止操作时一次性处理，称为“惰性求值”
/** * @author houChen * @date 2020/12/30 20:18 * @Description: * * 流的中间操作 */ 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 - 接受Lambda，从流中排除某些元素 limit - 截断流，使其元素不超过给定数量 skip - 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n，则返回一个空流。 distinct - 筛选，通过流所生成元素的hashCode()和equals()去除重复元素 */ //filter //内部迭代：迭代操作由Stream API完成 @Test public 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 @Test public void test2(){ employees.stream().filter((e) -> e.getAge() > 25) .limit(2).forEach(System.out::println); } //skip @Test public void test3(){ employees.stream().filter((e) -> e.getAge() > 25) .skip(2).forEach(System.out::println); } //distinct() 【注意】比较的元素需要equals()方法 @Test public void test4(){ employees.stream().filter((e) -> e.getAge() > 25) .skip(2).distinct().forEach(System.out::println); } }
6、Stream映射
/* 映射 map - 接受Lambda,将元素转换成其他形式或提取信息。接受一个函数作为参数，该函数会被应用到每个元素上，并将其 映射成一个新的元素。 flatMap - 接收一个函数作为参数，将流中的每个值都换成另一个值，然后把所有的流连接成一个流 */ //将元素中的所有元素转大写 @Test public 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(); }
7、Stream 排序
/* 排序： sorted() : 自然排序 sorted(Comparator com) ： 定制排序 */ @Test public 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); }
8、Stream查找与匹配、
查找与匹配
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 - 返回流中的最小值 */ @Test public void test(){ //allMatch boolean b = employees.stream() .allMatch((e) -> e.getStatus().equals(Employee.Status.Busy)); System.out.println(b); //anyMatch System.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); } @Test public 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()); } }
9、stream归约与收集
1）归约
reduce(T identity,BinaryOperater) / reduce(BinaryOperater)
可以将流中的元素反复结合起来，得到一个值
identity:起始值
BinaryOperater：二元运算符
【备注】map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名
/** * @author houChen * @date 2021/1/1 9:32 * @Description: * * 归约 * reduce(T identity,BinaryOperater) / reduce(BinaryOperater) * 可以将流中的元素反复结合起来，得到一个值 * identity:起始值 * BinaryOperater：二元运算符 * */ 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) ); @Test 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); } }
2）收集
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) ); @Test public 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); } @Test public 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()); } //分组 @Test public 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)); } } //多级分组 : 先按照状态分组，再按照青年、老年分组 @Test public 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); } //分区: // 满足条件的为一个区 // 不满足条件的为一个区 @Test public void test6(){ Map<Boolean, List<Employee>> map = employees.stream() .collect(Collectors.partitioningBy(e -> e.getSalary() > 8000)); System.out.println(map); } //将员工所有的名字取出来，并用"," 分隔 @Test public void test7(){ String namestr = employees.stream() .map(Employee::getName) .collect(Collectors.joining(",")); System.out.println(namestr); } }
