JDK8-17新特性-StreamAPI使用三环节：实例化、中间操作、终止操作

JDK8-17新特性-StreamAPI使用三环节：实例化、中间操作、终止操作

1.Stream API简介

• Stream API (java.util.stream)把真正的函数式编程风格引入到java中。这是目前为止对java类库最好的补充，因为Stream API可以极大提供java程序员的生产力，让程序员写出高效率、干净、简介的代码。

• Stream是java8中处理集合的关键抽象概念，他可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API对集合数据进行操作，就类似与使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

2.什么是Stream API

• Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

• Stream和Collection集合的区别: Collection是一种静态的内存数据结构，讲的是数据，而Stream是有关计算的，讲的是计算。前者主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。

3.为什么要使用Stream API

• 实际开发中，项目中多数数据源都来自于MySQL、Oracle等。但现在数据源可以更多了，有MongDB，Redis等，而这些NoSQL的数据就需要java层面去处理

注意事项:

• Stream自己不会存储元素

• Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。

• Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果

• Stream一旦执行了终止操作，就不能在调用其它中间操作或终止操作了。

4.Stream API vs 集合框架

• Stream API 关注的是多个数据的计算（排序、查找、过滤、映射、遍历等），面向CPU的。

• 集合关注的是数据的存储，面向内存的。

• Stream API之于集合，类似于SQL之于数据表的查询。

5.使用说明

• Stream自己不会存储元素

• Stream 不会改变源对象，相反，他们会返回一个持有结果的新Stream

• Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行中止此操作，就执行中间操作链并产生结果

• Stream一旦执行了终止操作，就不能在调用其它中间操作或终止操作了。

6.Stream执行流程

• 步骤一

  • Stream的实例化

• 创建Stream的三种方式

//创建 Stream方法一: 通过集合
@Test
void test21() {
    List<Employee> list = EmployeeData.getEmployees();
    //default Stream<E> stream() : 返回一个顺序流
    Stream<Employee> stream = list.stream();
​
    //default Stream<E> parallelStream() : 返回一个并行流
    Stream<Employee> stream1 = list.parallelStream();
​
    System.out.println(stream);
    System.out.println(stream1);
​
}
​
//创建一个Stream 方式二: 通过数组
@Test
void test22() {
    //调用Arrays类的static<T> Stream<T> stream(T[] array): 返回一个流
    Integer[] arr = new Integer[]{1, 2, 3, 4, 5};
​
    Stream<Integer> stream = Arrays.stream(arr);
​
    int[] arr1 = new int[]{1,2,3,4,5};
    IntStream stream1 = Arrays.stream(arr1);
}
​
//创建Stream 方式三: 通过Stream的of()
@Test
void test23() {
    Stream<String> stream = Stream.of("AA","BB","Employee");
}

• 步骤二

  • 一系列的中间操作

• 1-筛选与切片

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

//-筛选与切片
@Test
void test31() {
    // filter(Predicate p) - 接收Lambda，从流中排除某些元素
    //练习：查询员工表中的薪资大于7000的员工信息
    List<Employee> list = Employee.getEmployees();
    Stream<Employee> stream = list.stream();
    stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println);
​
    System.out.println();
    //limit(n) - 截断流，使其元素不超过给定数量。
    //如下1.1是错误的示例。因为stream已经执行了终止操作，就不可以再调用其它的中间操作或终止操作了。
    //1.1stream.limit(2).forEach(System.out::println);
    list.stream().filter(emp -> emp.getSalary() > 7000).limit(2).forEach(System.out::println);
​
    System.out.println();
    //skip(n) - 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit相反
    list.stream().skip(5).forEach(System.out::println);
​
    System.out.println();
    //distinct() - 筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素
    list.add(new Employee(1,"你爸爸",55,1000000));
    list.add(new Employee(1,"你爸爸",55,1000000));
    list.add(new Employee(1,"你爸爸",55,1000000));
    list.add(new Employee(1,"你爸爸",55,1000000));
    list.add(new Employee(1,"你爸爸",55,1000000));
​
    list.stream().distinct().forEach(System.out::println);
​
}

• 2-映射

方法	描述
map(Function f)	接受一个函数作为参数，该函数会被应用到 每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收到一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
mapToInt(TolntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的InStream。
mapRoLong(ToLongFunction f)	接受一个函数作为参数，该函数被应用到每个元素上，产生一个新的LongStream。
flatMap(Function f)	接收一个函数·作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

//2 - 映射
@Test
void test24() {
    //map(Function f) - 接受一个函数作为参数，将元素转换成其他形式或提取信息,该函数会被应用到每个元素上
    //练习：转换为大写
    List<String> list = Arrays.asList("aa","bb","c");
    //方式一：
    list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    //方式二：
    list.stream().map(String :: toUpperCase).forEach(System.out::println);
​
    //练习：获取员工姓名长度大于3的员工
    List<Employee> employees = EmployeeData.getEmployees();
    list.stream()
            .filter(emp -> emp.getName().length() > 3)
            .forEach(System.out::println);
​
    //练习:获取员工姓名长度大于3的员工的姓名
    //方式一：
    employees.stream()
            .filter(emp -> emp.getName().length() > 3)
            .map(emp -> emp.getName())
            .forEach(System.out::println);
    //方式二：
    employees.stream()
            .map(emp -> emp.getName())
            .filter(name -> name.length() > 3)
            .forEach(System.out::println);
    //方式三：
    employees.stream()
            .map(Employee :: getName)
            .filter(name -> name.length() > 3)
            .forEach(System.out::println);
​
}

• 3.排序

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序

//3 - 排序
@Test
public void test26(){
    //sorted() - 自然排序
    /*
       注意：并不会对容器本身进行更改
     */
    Integer[] arr = new Integer[]{1,2,3,5,4,4,5,4,878,7};
    String[] arr1 = new String[]{"aa","cc","hj"};
​
    Arrays.stream(arr)
            .sorted()
            .forEach(System.out::println);
​
    System.out.println(Arrays.toString(arr));
​
    Arrays.stream(arr1)
            .sorted()
            .forEach(System.out::println);
​
    //sorted(Comparatar com) - 定制排序
    List<Employee> list = EmployeeData.getEmployees();
    list.stream()
            .sorted((e1,e2) -> e1.getAge() - e2.getAge())
            .forEach(System.out::println);
​
    //针对于字符串从大到小排序（降序）
    Arrays.stream(arr1)
            .sorted((s1,s2) -> s1.compareTo(s2))
            .forEach(System.out::println);
​
    //升序
    Arrays.stream(arr1)
            .sorted(String :: compareTo)
            .forEach(System.out::println);
​
}

• 步骤三

  • 执行终止操作

• 1 - 匹配与查找

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是够至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
count()	返回流中的元素总数
findAny()	返回当前流中的任意元素
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代使用Collection接口需要用户去做迭代，称为外部迭代。 相反，Stream API使用内部迭代 -- 它帮你把迭代做了

//1 - 匹配与查找
@Test
void test01() {
    //allMatch(Predicate p) 检查是否匹配所有元素
    //练习：是否所有员工的年龄都 大于 18
    List<Employee> list = EmployeeData.getEmployees();
    System.out.println(list.stream().allMatch(emp -> emp.getAge() > 18));
​
    //anyMatch(Predicate p)检查是够至少匹配一个元素
    //练习：是否存在年龄大于18岁的员工
    System.out.println(list.stream().anyMatch(emp -> emp.getAge() > 18));
​
    //练习：是否存在员工的工资大于 10000
    System.out.println(list.stream().anyMatch(emp -> emp.getSalary() > 10000));
​
    //findFirst - 返回第一个元素
    System.out.println(list.stream().findFirst().get());
}
​
@Test
void test02() {
    //count - 返回流中元素的总个数
    List<Employee> list = EmployeeData.getEmployees();
    System.out.println(list.stream().filter(emp -> emp.getSalary() > 7000).count());
​
    //max(Comparator c) - 返回流中的最大值
    //练习：返回最高工资的员工
    //方式一：
    System.out.println(list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    //方式二：
    System.out.println(list.stream().map(emp -> emp.getSalary()).max((s1,s2) -> Double.compare(s1,s2)).get());
    //方式三：
    list.stream().map(emp -> emp.getSalary()).max(Double :: compare).get();
​
    //min(Comparator c) - 返回流中的最小值
    //练习：返回工资最低的员工
    list.stream().min((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary())).get();
​
    //forEach(Consumer c) - 内部迭代
    list.stream().forEach(System.out::println);
​
    //针对于集合，jdk8中增加了一个遍历的方法
    list.forEach(System.out::println);
    
    //针对于List来说，遍历的方式：1.使用Iterator 2.增强for 3.一般for 4.forEach()
    
}

• 2 - 归约

方法	描述
redce(T identity，BinaryOperator b)	可以将流中的元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional<T>

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

//2 - 归约
@Test
void test03() {
    // reduce(T identity,BinaryOperator) - 可以将流中元素反复结合起来，得到一个值。返回T
    // 练习1：计算 1 - 10 的自然数和
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    //写法一：
    System.out.println(list.stream().reduce(0, (x1, x2) -> x2 + x1));
    //写法二：
    System.out.println(list.stream().reduce(0, (x1, x2) -> Integer.sum(x2,x1)));
    //写法三：
    System.out.println(list.stream().reduce(0, Integer::sum));
​
    System.out.println(list.stream().reduce(10, (x1, x2) -> x1 + x2));
​
    //reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回Optional<T>
    //练习二：计算公司所有员工工资的总和
    List<Employee> employeeList = EmployeeData.getEmployees();
    System.out.println(employeeList.stream()
            .map(emp -> emp.getSalary())
            .reduce((s1, s2) -> Double.sum(s1, s2)));
​
    System.out.println(employeeList.stream().reduce(0, Double::sum));
    
}

• 3 - 收集

方法	描述
collect(Collector c)	将流转换成其他形式。接受一个Collector接口的实现， 用于给Stream中元素做汇总的方法

Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到 List、Set、Map）。

    //3 - 收集
    @Test
    void test04() {
        List<Employee> list = EmployeeData.getEmployees();
        //collect(Collector c)将流转换成其他形式。接受一个Collector接口的实现，<br>用于给Stream中元素做汇总的方法
        //练习1：查找工资大于6000的员工，结果返回一个List或Set
        List<Employee> list1 = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
        list1.forEach(System.out::println);
        System.out.println();
        list.forEach(System.out::println);
        System.out.println();
​
        //练习2：按照员工的年龄进行排序，返回一个新的List中
        List<Employee> list2 = list.stream().sorted((e1,e2) -> e1.getAge() -e2.getAge()).collect(Collectors.toList());
        list2.forEach(System.out::println);
    }
}