javajavase

StreamAPI

概述

  • Stream关注的是对数据的运算，与CPU打交道；集合关注的是数据的存储，与内存打交道
  • Java 8提供了一套API，使用这套API可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作
  • Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据， Stream讲的是计算”

特点

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

使用流程

  1. 创建Stream对象
  2. 一系列的中间操作（过滤、映射、…)
  3. 终止操作

StreamAPI、Optional类 - 图1
说明

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

  • 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

    使用方法

    1️⃣步骤一 创建Stream

    创建方式一：通过集合
    Java 8的Collection接口被扩展，提供了两个获取流的方法：
    **default Stream<E> stream()** 返回一个顺序流
    **default Stream<E> parallelStream()** 返回一个并行流
    创建方式二：通过数组
    Java 8中的Arrays的静态方法stream()可以获取数组流
    **static<T> Stream<T> stream(T[] array**) 返回一个流
    重载形式，能够处理对应基本类型的数组
    **public static IntStream stream(int[] array)**
    **public static LongStream stream(long[] array)**
    **public static DoubleStream stream(double[] array)**
    创建方式三：通过Stream的of()方法
    可以调用Stream类静态方法of()，通过显示值创建一个流。可以用于接收任意数量的参数
    **public static <T> Stream<T> of(T... values)** 返回一个流
    创建方式四：创建无限流

  • 迭代

**public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)**

  • 生成

**public static<T> Stream<T> generate(Supplier<T> s)**

  1. public class StreamAPITest {
  2.     // 创建 Stream方式一：通过集合
  3.     @Test
  4.     public void test1() {
  5.         List<Employee> employees = EmployeeData.getEmployees();
  7.         // default Stream<E> stream() : 返回一个顺序流
  8.         Stream<Employee> stream = employees.stream();
  10.         // default Stream<E> parallelStream() : 返回一个并行流
  11.         Stream<Employee> parallelStream = employees.parallelStream();
  12.     }
  14.     // 创建 Stream方式二：通过数组
  15.     @Test
  16.     public void test2() {
  17.         int[] arr = new int[]{1,2,3,4,5,6};
  18.         // 调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
  19.         IntStream stream = Arrays.stream(arr);
  21.         Employee e1 = new Employee(1001,"Tom");
  22.         Employee e2 = new Employee(1002,"Jerry");
  23.         Employee[] arr1 = new Employee[]{e1, e2};
  24.         Stream<Employee> stream1 = Arrays.stream(arr1);
  25.     }
  27.     // 创建 Stream方式三：通过Stream的of()
  28.     @Test
  29.     public void test3() {
  30.         Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
  31.     }
  33.     //创建 Stream方式四：创建无限流
  34.     @Test
  35.     public void test4(){
  36.         // 迭代
  37.         // public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
  38.         // 遍历前10个偶数
  39.         Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
  41. //      生成
  42. //      public static<T> Stream<T> generate(Supplier<T> s)
  43.         Stream.generate(Math::random).limit(10).forEach(System.out::println);
  44.     }
  45. }

2️⃣步骤二 中间操作

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

筛选与切片

StreamAPI、Optional类 - 图2

  1. @Test
  2. public void test1() {
  3.     List<Employee> list = EmployeeData.getEmployees();
  5.     // filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
  6.     Stream<Employee> stream = list.stream();
  7.     // 练习：查询员工表中薪资大于7000的员工信息
  8.     stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
  9.     System.out.println();
  11.     // limit(n)——截断流，使其元素不超过给定数量。
  12.     list.stream().limit(3).forEach(System.out::println);
  13.     System.out.println();
  15.     // skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。
  16.     // 若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
  17.     list.stream().skip(3).forEach(System.out::println);
  18.     System.out.println();
  20.     //distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
  21.     list.add(new Employee(1010,"刘强东",40,8000));
  22.     list.add(new Employee(1010,"刘强东",41,8000));
  23.     list.add(new Employee(1010,"刘强东",40,8000));
  24.     list.add(new Employee(1010,"刘强东",40,8000));
  25.     list.add(new Employee(1010,"刘强东",40,8000));
  27.     list.stream().distinct().forEach(System.out::println);
  28. }

映射

StreamAPI、Optional类 - 图3

  1. @Test
  2. public void test2() {
  3.     // map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，
  4.     // 该函数会被应用到每个元素上，并将其映射成一个新的元素。
  5.     List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
  6.     list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
  8.     // 练习：获取员工姓名长度大于3的员工的姓名。
  9.     List<Employee> employees = EmployeeData.getEmployees();
  10.     Stream<String> namesStream = employees.stream().map(Employee::getName);
  11.     namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
  12.     System.out.println();
  14.     // flatMap(Function f)
  15.     Stream<Stream<Character>> streamStream = list.stream()
  16.         .map(StreamAPITest1::fromStringToStream);
  17.     streamStream.forEach(s -> {s.forEach(System.out::println);});
  18.     System.out.println();
  20.     // flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，
  21.     // 然后把所有流连接成一个流。
  22.     Stream<Character> characterStream = list.stream()
  23.         .flatMap(StreamAPITest1::fromStringToStream);
  24.     characterStream.forEach(System.out::println);
  25. }
  27. // 将字符串中的多个字符构成的集合转换为对应的Stream的实例
  28. public static Stream<Character> fromStringToStream(String str) {    //aa
  29.     ArrayList<Character> list = new ArrayList<>();
  30.     for (Character c : str.toCharArray()) {
  31.         list.add(c);
  32.     }
  33.     return list.stream();
  34. }
  36. @Test
  37. public void test3() {
  38.     ArrayList list1 = new ArrayList();
  39.     list1.add(1);
  40.     list1.add(2);
  41.     list1.add(3);
  43.     ArrayList list2 = new ArrayList();
  44.     list2.add(4);
  45.     list2.add(5);
  46.     list2.add(6);
  48.     list1.add(list2);    // 4个元素，类似map
  49.     list1.addAll(list2);    // 6个元素，类似flatmap
  50.     System.out.println(list1);
  51. }

排序

StreamAPI、Optional类 - 图4

  1. @Test
  2. public void test4() {
  3.     // sorted()——自然排序
  4.     List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
  5.     list.stream().sorted().forEach(System.out::println);
  7.     // 抛异常，原因:Employee没有实现Comparable接口
  8.     // List<Employee> employees = EmployeeData.getEmployees();
  9.     // employees.stream().sorted().forEach(System.out::println);
  11.     // sorted(Comparator com)——定制排序
  12.     List<Employee> employees = EmployeeData.getEmployees();
  13.     employees.stream().sorted((e1, e2) -> {
  14.         int ageValue = Integer.compare(e1.getAge(), e2.getAge());
  15.         if (ageValue != 0) {
  16.             return ageValue;
  17.         } else {
  18.             return -Double.compare(e1.getSalary(), e2.getSalary());
  19.         }
  20.     }).forEach(System.out::println);
  21. }

3️⃣步骤三 终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、 Integer，甚至是void
流进行了终止操作后，不能再次使用。

匹配与查找

StreamAPI、Optional类 - 图5
StreamAPI、Optional类 - 图6

  1. @Test
  2. public void test1() {
  3.     List<Employee> employees = EmployeeData.getEmployees();
  5.     // allMatch(Predicate p)——检查是否匹配所有元素。
  6.     // 练习：是否所有的员工的年龄都大于18
  7.     boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
  8.     System.out.println(allMatch);
  10.     // anyMatch(Predicate p)——检查是否至少匹配一个元素。
  11.     // 练习：是否存在员工的工资大于 10000
  12.     boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
  13.     System.out.println(anyMatch);
  15.     // noneMatch(Predicate p)——检查是否没有匹配的元素。
  16.     // 练习：是否存在员工姓“雷”
  17.     boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
  18.     System.out.println(noneMatch);
  20.     // findFirst——返回第一个元素
  21.     Optional<Employee> employee = employees.stream().findFirst();
  22.     System.out.println(employee);
  24.     // findAny——返回当前流中的任意元素
  25.     Optional<Employee> employee1 = employees.parallelStream().findAny();
  26.     System.out.println(employee1);
  27. }
  29. @Test
  30. public void test2() {
  31.     List<Employee> employees = EmployeeData.getEmployees();
  33.     // count——返回流中元素的总个数
  34.     long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
  35.     System.out.println(count);
  37.     // max(Comparator c)——返回流中最大值
  38.     // 练习：返回最高的工资：
  39.     Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
  40.     Optional<Double> maxSalary = salaryStream.max(Double::compare);
  41.     System.out.println(maxSalary);
  43.     // min(Comparator c)——返回流中最小值
  44.     // 练习：返回最低工资的员工
  45.     Optional<Employee> employee = employees.stream()
  46.         .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
  47.     System.out.println(employee);
  48.     System.out.println();
  50.     // forEach(Consumer c)——内部迭代
  51.     employees.stream().forEach(System.out::println);
  53.     // 使用集合的遍历操作
  54.     employees.forEach(System.out::println);    // 俩forEach()原理不同
  55. }

归约

StreamAPI、Optional类 - 图7

备注：map和reduce的连接通常称为 map-reduce模式，因Google用它来进行网络搜索而出名

  1. @Test
  2. public void test3() {
  3.     // reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
  4.     // 练习1：计算1-10的自然数的和
  5.     List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  6.     Integer sum = list.stream().reduce(0, Integer::sum);
  7.     System.out.println(sum);
  9.     // reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
  10.     // 练习2：计算公司所有员工工资的总和
  11.     List<Employee> employees = EmployeeData.getEmployees();
  12.     Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
  13.     Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
  14.     // Optional<Double> sumMoney = salaryStream.reduce((d1, d2) -> d1 + d2);
  15.     System.out.println(sumMoney.get());
  16. }

收集

StreamAPI、Optional类 - 图8
Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List、Set、Map）
Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例具体方法与实例如下表
StreamAPI、Optional类 - 图9
StreamAPI、Optional类 - 图10

  1. @Test
  2. public void test4(){
  3.     // collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，
  4.     // 用于给Stream中元素做汇总的方法
  5.     // 练习1：查找工资大于6000的员工，结果返回为一个List或Set
  6.     List<Employee> employees = EmployeeData.getEmployees();
  8.     List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000)
  9.         .collect(Collectors.toList());
  10.     employeeList.forEach(System.out::println);
  11.     System.out.println("-------------------");
  13.     Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000)
  14.         .collect(Collectors.toSet());
  15.     employeeSet.forEach(System.out::println);
  16. }

Optional类

概述
为了解决java中的空指针问题而生
Optional 类(java.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常

Optional类提供的方法

Optional类提供了很多方法，可以不用再现实的进行空值检验

  • 创建Optional类对象的方法

**Optional.of(T t)** 创建一个Optional实例，t必须非空；
**Optional.empty()** 创建一个空的 Optional 实例
**Optional.ofNullable(T t)** t可以为null

  • 判断Optional容器是否包含对象

**boolean isPresent()** 判断是否包含对象
**void ifPresent(Consumer<? super T> consumer)**
如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。

  • 获取Optional容器的对象

**T get()** 如果调用对象包含值，返回该值，否则抛异常
**T orElse(T other)** 如果有值则将其返回，否则返回指定的other对象
**T orElseGet(Supplier<? extends t> other)**
如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
**T orElseThrow(Supplier<? extends X> exceptionSupplier)**
如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

  • 搭配使用

of() 和 get() 方法搭配使用，明确对象非空
ofNullable() 和 orElse() 搭配使用，不确定对象非空

  1. @Test
  2. public void test1() {
  3.     Girl girl = new Girl();
  4.     // of(T t):保证t是非空的
  5.     // girl = null;
  6.     Optional<Girl> optionalGirl = Optional.of(girl);
  7. }
  9. @Test
  10. public void test2() {
  11.     Girl girl = new Girl();
  12.     // ofNullable(T t)：t可以为null
  13.     girl = null;
  14.     Optional<Girl> optionalGirl = Optional.ofNullable(girl);
  15.     System.out.println(optionalGirl);
  17.     // orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t.
  18.     Girl girl1 = optionalGirl.orElse(new Girl("赵丽颖"));
  19.     System.out.println(girl1);
  20. }
  23. public String getGirlName(Boy boy) {
  24.     return boy.getGirl().getName();
  25. }
  27. @Test
  28. public void test3() {
  29.     Boy boy = new Boy();
  30.     // boy = null;
  31.     String girlName = getGirlName(boy);
  32.     System.out.println(girlName);
  33. }
  36. // 优化以后的getGirlName():
  37. public String getGirlName1(Boy boy) {
  38.     if (boy != null) {
  39.         Girl girl = boy.getGirl();
  40.         if (girl != null) {
  41.             return girl.getName();
  42.         }
  43.     }
  44.     return null;
  45. }
  47. @Test
  48. public void test4() {
  49.     Boy boy = new Boy();
  50.     // boy = null;
  51.     String girlName = getGirlName1(boy);
  52.     System.out.println(girlName);
  53. }
  56. // 使用Optional类的getGirlName():
  57. public String getGirlName2(Boy boy) {
  58.     Optional<Boy> boyOptional = Optional.ofNullable(boy);
  59.     // 此时的boy1一定非空
  60.     Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
  61.     Girl girl = boy1.getGirl();
  63.     Optional<Girl> girlOptional = Optional.ofNullable(girl);
  64.     // girl1一定非空
  65.     Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));
  67.     return girl1.getName();
  68. }
  70. @Test
  71. public void test5() {
  72.     Boy boy = null;
  73.     boy = new Boy();
  74.     boy = new Boy(new Girl("苍老师"));
  75.     String girlName = getGirlName2(boy);
  76.     System.out.println(girlName);
  77. }
  1. public class Boy {
  2.     private Girl girl;
  4.     public Girl getGirl() {
  5.         return girl;
  6.     }
  8.     public void setGirl(Girl girl) {
  9.         this.girl = girl;
  10.     }
  12.     public Boy() {}
  14.     public Boy(Girl girl) {
  15.         this.girl = girl;
  16.     }
  18.     //toString()等略
  19. }