Stream API

Stream API

StreamAPI（java.util.stream）把真正的函数式编程风格引入到Java中，这是目前为止对Java类库最好的补充

StreamAPI实现将数据在后端去操作

StreamAPI和集合框架的区别

  • Stream API关注的是数据的计算（排序、查找、过滤、映射、遍历），面向CPU
  • 集合关注的是数据的存储，面向内存的
  • Stream API之于集合，类似于SQL之余数据表的查询

使用说明

  • Stream自己不会存储元素
  • Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream
  • Stream操作时延迟进行的，这意味着它们会等到需要结果的时候才执。一旦中途执行中止操作，就执行中间操作链，并产生结果
  • Stream一旦执行了终止操作，就不能再调用其他中间操作或终止操作了

Stream执行流程

  • Steam的实例化

  • 一系列的中间操作

  • 执行中止操作

创建Stream

创建Stream方式一：通过集合

结构Collection中提供了一个stream方法，可通过集合获取顺序流和并行流

@Test
public void test(){
    //创建Stream方式一：通过集合
    //结构Collection中提供了一个stream方法，可通过集合获取顺序流和并行流
    List list = new ArrayList();
    //获取一个顺序流
    list.stream();
    //获取一个并行流
    list.parallelStream();
}
创建Stream方式二：通过数组

调用Arrays类的static <T> Stream <T> stream(T[] array)：返回一个流

@Test
public void test1(){
    Integer[] arr = new Integer[]{1,2,3,4,5};
    Stream<Integer> stream = Arrays.stream(arr);
    //基本数据类型不能当作泛型使用，所以有专门的基本数据类型Stream
    int[] ints = {1, 2, 3, 4, 5};
    IntStream stream1 = Arrays.stream(ints);
}
创建Stream方式三：通过Stream的of()
@Test
public void test3() {
    Stream<String> stream = Stream.of("AA", "BB", "CC");
}

Stream的中间操作（方法）

在此我们建立一个实体类Employee

public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

在此我们建立一个数据集合类EmployeeDate，此类中有get方法返回一个Employee类型的List集合

import java.util.ArrayList;
import java.util.List;

public class EmployeeDate {
    public static List<Employee> getEmployees(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(1001,"马化腾",34,6000.38));
        list.add(new Employee(1002,"马云",2,9876.12));
        list.add(new Employee(1003,"刘强东",33,3000.82));
        list.add(new Employee(1004,"雷军",26,7657.37));
        list.add(new Employee(1005,"李彦宏",65,5555.32));
        list.add(new Employee(1005,"比尔盖茨",42,9500.43));
        list.add(new Employee(1006,"任正非",26,4333.32));
        list.add(new Employee(1007,"扎克伯格",35,2500.32));
        return list;
    }
}
筛选与切片
方法名说明
filter()过滤
limit()截取
skip()跳过
distinct()筛选（去重）
@Test
public void test() {
    //练习：查询员工表中薪资大于7000的员工信息
    List<Employee> list = EmployeeDate.getEmployees();
    Stream<Employee> stream = list.stream();

    //使用流过滤工资（salary）大于七千的，并终止操作（输出到控制台）
    stream.filter(employee -> employee.getSalary() > 7000).forEach(System.out::println);
    
    System.out.println();
    //终止操作之后，此Stream将无法再进行任何中间操作
    
    //单独的流执行截取前四段，并终止操作（输出到控制台）
    list.stream().limit(4).forEach(System.out::println);
    
    //相同的，如果没有进行终止操作，可以进行多步中间操作（方法链）
    list.stream().filter(employee -> employee.getSalary() > 7000).limit(2).forEach(System.out::println);
    
    //跳过前五个
    list.stream().skip(5).forEach(System.out::println);
    
    //筛选（去重）
    list.add(new Employee(1009, "马斯克", 40, 12500.32));
    list.add(new Employee(1009, "马斯克", 40, 12500.32));
    list.add(new Employee(1009, "马斯克", 40, 12500.32));
    list.add(new Employee(1009, "马斯克", 40, 12500.32));
    list.stream().distinct().forEach(System.out::println);
}
映射
方法名说明
map(Function f)接受一个函数作为参数，将元素转换为其他形式或提取信息

该方法会被应用到每一个元素上

    @Test
    public void test1() {
        //练习：转大写
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(String::toUpperCase).forEach(System.out::println);
        System.out.println();
        //练习：获取员工姓名大于3的员工的姓名
        List<Employee> list1 = EmployeeDate.getEmployees();
        //方式1：先过滤出名字大于3的再提取名字
        list1.stream().filter(employee -> employee.getName().length() > 3).map(employee -> employee.getName()).forEach(System.out::println);
        //方式2：先提取所有名字，再去找长度大于三的
        list1.stream().map(employee -> employee.getName()).filter(name -> name.length() > 3).forEach(System.out::println);
        //方式3：使用方法引用
        list1.stream().filter(employee -> employee.getName().length() > 3).map(Employee::getName).forEach(System.out::println);
    }
排序
方法名说明
sorted()自然排序（默认升序）
sorted(Comparator com)定制排序（默认升序）
sorted((s1,s2)->-s1.compareTo(s2))降序排列
    @Test
    public void test2(){
        Integer[] integers = {345, 3, 64, 3, 45, 7, 3, 34, 65, 68};
        //使用方式2构建stream流
        Arrays.stream(integers).sorted().forEach(System.out::println);

        //字符数组也可以实现自然排序
        String[] strings = {"GG", "MM", "SS", "JJ", "DD"};
        Arrays.stream(strings).sorted().forEach(System.out::println);
        //降序排列
        Arrays.stream(strings).sorted(String::compareTo).forEach(System.out::println);

        //实体类对象不能实现自然排序，因为没有实现自然排序接口
//        List<Employee> list = EmployeeDate.getEmployees();
//        list.stream().sorted().forEach(System.out::println);

        //定制排序：sorted(Comparator com)
        List<Employee> list = EmployeeDate.getEmployees();
        list.stream().sorted((e1,e2)->e1.getAge() - e2.getAge()).forEach(System.out::println);
    }

Stream的终止操作

匹配与查找
方法名说明
allMatch()全部元素匹配条件才为true
anyMatch()有一个元素匹配条件就为true
findFirst()返回第一个元素
@Test
public void test4(){
    //查询集合里的员工是否全都大于18岁
    List<Employee> list = EmployeeDate.getEmployees();
    System.out.println(list.stream().allMatch(employee -> employee.getAge() > 18));
    //查询集合里的员工是否存在大于18岁
    System.out.println(list.stream().anyMatch(employee -> employee.getAge() > 18));
    //返回第一个元素
    System.out.println(list.stream().findFirst());
}
方法名说明
count()返回流中元素的个数
max(Comparator c)返回最高的
min(Comparator c)返回最低的
@Test
public void test5(){
    //返回流中元素个数
    List<Employee> list = EmployeeDate.getEmployees();
    System.out.println(list.stream().count());
    //返回最高的工资的员工
    System.out.println(list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    //返回最高工资
    //方式一
    System.out.println(list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).get().getSalary());
    //方式二
    System.out.println(list.stream().map(employee -> employee.getSalary()).max(Double::compare).get());
}

返回最低工资同理

方法名说明
forEach(Consumer c)内部迭代
@Test
public void test(){
    List<Employee> list = EmployeeDate.getEmployees();
    //内部迭代
    list.stream().forEach(System.out::println);
}

list集合的遍历方式

  • 使用Iterator
  • 增强for
  • 一般for
  • forEach**（新增）**
//针对于集合，jdk8中增加了一个遍历的方法
list.forEach(System.out::println);
归约
方法名说明
reduce(T identity, BinaryOperator)可以将流中元素反复结合起来，得到一个值，返回T
reduce(BinaryOperator)可以将流中元素反复结合起来，得到一个值，返回Optional<T>
@Test
public void test2() {
    //练习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) -> x1 + x2));
    System.out.println(list.stream().reduce(0, Integer::sum));//方法引用

    //求所有员工的工资和
    List<Employee> list1 = EmployeeDate.getEmployees();
    System.out.println(list1.stream().map(employee -> employee.getSalary()).reduce((salary1, salary2) -> Double.sum(salary1, salary2)));
    System.out.println(list1.stream().map(employee -> employee.getSalary()).reduce(Double::sum));
}
收集
方法名说明
collect(Collector c)将流转换为其他形式，接受一个collector接口的实现。用于给Stream中的元素做汇总的方法

另外Collector类给提供了很多静态方法，可供作为collect方法的参数使用