您好,欢迎来到二三娱乐。
搜索
您的当前位置:首页Stream

Stream

来源:二三娱乐

什么是流

Stream 不是集合元素,它不是数据结构并不保存数据,它更像一个高级版本的 Iterator。原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作;高级版本的 Stream,用户只要给出需要对其包含的元素执行什么操作,比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等,Stream 会隐式地在内部进行遍历,做出相应的数据转换。

Stream 就如同一个迭代器(Iterator),单向,不可往复,数据只能遍历一次,遍历过一次后即用尽了,就好比流水从面前流过,一去不复返。

而和迭代器又不同的是,Stream 可以并行化操作,迭代器只能命令式地、串行化操作。顾名思义,当使用串行方式去遍历时,每个 item 读完后再读下一个 item。而使用并行去遍历时,数据会被分成多个段,其中每一个都在不同的线程中处理,然后将结果一起输出。

【注意】

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

流的构成

当我们使用一个流的时候,通常包括三个基本步骤:

获取一个数据源(source)→ 数据转换→执行操作获取想要的结果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以像链条一样排列,变成一个管道,如下图所示。

【创建Stream】

public class TestStreamAPI1 {

    /**
     * 创建Stream
     */
    @Test
    public void test1(){
        //1. 可以通过Collection系列集合提供的stream()或parallelStream()
        //stream():获取串行流   parallelStream():获取并行流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //2. 通过Arrays中的静态方法stream()获取数组流
        String[] array = new String[10];
        Stream<String> stream2 = Arrays.stream(array);

        //3. 通过Stream类中的静态方法of()
        Stream<String> stream3 = Stream.of("aa","bb","cc");

        //4. 创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0,(x)->x+2); //第一个参数是起始值,第二个参数是操作
        //stream4.forEach(System.out::print);   从0开始做x+2的操作,然后无限输出
        stream4.limit(10).forEach(System.out::print);  //只输出10个结果

        //生成
        Stream.generate(()->Math.random())
                       .limit(5)  //限制只产生5个随机数
                       .forEach(System.out::print);
    }
}

【Stream的中间操作】

准备操作

public class Employee {
    public String name;
    public Integer age;
    public Double salary;
    public Status status;

    public Employee(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    @Override
    public boolean equals(Object o) {
        ...
        //自动生成的equals方法,太长了此处省略
    }

    @Override
    public int hashCode() {
        int result = getName() != null ? getName().hashCode() : 0;
        result = 31 * result + (getAge() != null ? getAge().hashCode() : 0);
        result = 31 * result + (getSalary() != null ? getSalary().hashCode() : 0);
        return result;
    }

   public enum Status{
        FREE,
        BUSY,
        VOCATION;
    }
   // 此处省略getter和setter
}

(1)筛选与切片

  • filter —— 接收lambda,从中筛选某些元素
  • limit(N) —— 截断流,使其元素不超过给定量
  • skip(N) —— 跳过元素,返回一个扔掉了前N个元素的流。若流中的元素不足N个,则返回一个空流,和limit(N)互补
  • distinct —— 筛选,通过该流所生成的元素的 hashCode() 和 equals() 去除重复元素
public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY),
            new Employee("田七",45,8888.88, Employee.Status.BUSY),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test1(){

        // 中间操作:不会执行任何处理
        Stream s = employees.stream()
                .filter((e) -> { //参数为Predicate
                    System.out.print("Stream API的中间操作");
                    return e.getAge() >35;
                } );

        // 终止操作:只有执行终止操作,所有的中间操作才会一次性全部执行
        s.forEach(System.out::println);
    }

    @Test
    public void test2(){
        //取前两个结果
        employees.stream()
                 .filter(e->e.getSalary()>5000)
                 .limit(10)
                 .forEach(System.out::println);
    }

    @Test
    public void test3(){
        //跳过前两个结果
        employees.stream()
                .filter(e->e.getSalary()>5000)
                .skip(2)
                .forEach(System.out::println);
    }

    @Test
    public void test4(){
        //要想去除重复元素,Employee必须重写hashCode和equals方法
        employees.stream()
                .filter(e->e.getSalary()>5000)
                .skip(2)
                .distinct()
                .forEach(System.out::println);
    }
}

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

此外,迭代操作是由Stream API给我们完成的,称为内部迭代,不用我们自己手动迭代。

(2)映射

  • map:接收Lambda,将元素转换成其他形式或提取信息,接受一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
  • flatMap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有的流连接成一个流。
public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test5(){

        List<String> list = Arrays.asList("aaa","bbb","ccc","eee","ddd");
        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("---------------------");

        //map返回一个Stream,filterCharacter函数返回的也是一个 Stream
        //filterCharacter函数功能就是:提取出来一个数如aaa,转换成流然后返回
        Stream<Stream<Character>> stream = list.stream()
                .map(TestStreamAPI1::filterCharacter); //{{a,a,a} {b,b,b},...}

        stream.forEach((sm)->{
            sm.forEach(System.out::println);
        });

        System.out.println("---------------------");

        //使用flatMap简化上面的操作
        Stream<Character> sm = list.stream()
                .flatMap(TestStreamAPI1::filterCharacter); //{a,a,a,b,b,b,...}
        sm.forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();

        //将字符串变成字符数组
        for(Character ch:str.toCharArray()){
            list.add(ch);
        }

        return list.stream();
    }
}

从上面的代码中我们可以知道,Map是把整个集合添加到当前集合中,flatMap是把集合中每一个元素添加到当前集合中:

(3)排序

  • sort():自然排序(Comparable),就是按照String写好的方法排序
  • sorted(Comparator com):定制排序(Comparator)
public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test6(){
        List<String> list = Arrays.asList("aaa","bbb","ccc","eee","ddd");

        list.stream()
            .sorted()
            .forEach(System.out::println);

        System.out.println("---------------------");

        employees.stream()
                .sorted((e1,e2)->{
                    if(e1.getAge().equals(e2.getAge())){
                        return 
                    }else{
                        return 
                    }
                })
                .forEach(System.out::println);

    }
}

【Stream的终止操作】

(1)查找与匹配

  • allMatch:检查是否匹配所有元素
  • anyMatch:检查是否至少匹配一个元素
  • noneMatch:检查是否没有匹配所有元素
  • findFirst:返回第一个元素
  • findAny:返回流中元素的总个数
  • count:返回流中元素的总个数
  • max:返回流中最大值
  • min:返回流中最小值
public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test1(){
        //判断是否所有的employee都是Status.BUSY状态
        boolean b1 = employees.stream()
                .allMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b1);

        //是否至少有一个employee是Status.BUSY状态
        boolean b2 = employees.stream()
                .anyMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b2);

        //是不是没有employee是Status.BUSY状态
        boolean b3 = employees.stream()
                .noneMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b3);

        //获取工资最高的employee
        Optional<Employee> op = employees.stream()
                
                .findFirst();  //结果有可能为空,所以封装到Optional中去

        System.out.print(op.get());

        //找空闲状态的员工
        Optional<Employee> op1 = employees.stream()
                .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                .findAny();
        System.out.print(op1.get());   //因为是串行流,按顺序找的,所以获取到的一直是张三

        Optional<Employee> op2 = employees.parallelStream()
                .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                .findAny();
        System.out.print(op1.get());   //并行流,多个员工同时找,所以获取到的是张三或者赵六

    }

    @Test
    public void test2(){
        Long count = employees.stream().count();

        //提取工资最高的员工
        Optional<Employee> op1 = employees.stream()
                
        System.out.print(op1.get());

        //获取公司中最小的工资是多少
        Optional<Double> op2 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .min(Double::compare);
        System.out.print(op1.get());

    }

}

(2)规约

  • reduce(T identify,BinaryOperator) /:可以将流中元素反复结合起来,得到一个值,返回T。T identify为起始值,BinaryOperator为二元运算。
  • reduce(BinaryOperator):可以将流中元素反复结合起来,得到一个值,返回Optional<T>。

map和reduce的连接通常称为map-reduce模式,用于大数据。

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test2(){
        Long count = employees.stream().count();

        //提取工资最高的员工
        Optional<Employee> op1 = employees.stream()
                
        System.out.print(op1.get());

        //获取公司中最小的工资是多少
        Optional<Double> op2 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .min(Double::compare);
        System.out.print(op1.get());

    }

    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);

        //reduce一开始把0作为x,list中第一个元素作为y,实现x+y=1,然后再把1作为x,2作为y...,就这样将元素反复结合起来
        Integer sum = list.stream()
                .reduce(0,(x,y)->x+y);
        System.out.print(sum);

        System.out.print("--------------------------");

        //计算公司工资总和
        Optional<Double> op1 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .reduce(Double::sum);
        System.out.print(op1.get());
    }

}

(3)收集

  • collect(Collector c):将流转换为其他形式,接收一个Collector接口的实现,用于给Stream中元素做汇总的方法。

Collector接口中的方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collector实用类提供了很多静态方法,可以方便地创建常见收集器实例。

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );


    @Test
    public void test4(){
        //将公司当前所有人的名字收集到一个list中去
        List<String> list = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        list.forEach(System.out::println);

        System.out.println("----------------------");

        //将公司当前所有人的名字收集到一个set中去,可以避免重复值
        Set<String> set = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("----------------------");

        //将公司当前所有人的名字收集到一个自定义的特殊集合中去,这里为HashSet
        HashSet<String> sh = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        sh.forEach(System.out::println);
    }

    @Test
    public void test5(){
        //收集员工总数
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println(count);
        System.out.println("----------------------");

        //平均数
        Double avg = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);
        System.out.println("----------------------");

        //工资总和
        Double sum = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);
        System.out.println("----------------------");

        //最大值,得到工资最高的employee
        Optional<Employee> max = employees.stream()
                
        System.out.println(max.get());

        //最小值
        Optional<Double> min = employees.stream()
                .map(Employee::getSalary)
                .collect(Collectors.minBy(Double::compare));
        System.out.println(min.get());
    }

    //分组
    @Test
    public void test6(){
        Map<Employee.Status,List<Employee>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(map);
    }
}

    //多级分组
    @Test
    public void test7(){
        //先按状态分组,再按照年龄段分组
        Map<Employee.Status,Map<String,List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus,Collectors.groupingBy(e->{
                    if(e.getAge() <= 35){
                        return "青年";
                    }else if(e.getAge() <= 50){
                        return "中年";
                    }else{
                        return "老年";
                    }
                })));
        System.out.println(map);
    }

   //分区:满足条件的一个区,不满足条件的一个区
    @Test
    public void test8(){
        //先按状态分组,再按照年龄段分组
        Map<Boolean,List<Employee>> map = employees.stream()
                .collect(Collectors.partitioningBy((e)->e.getSalary()>8000));
        System.out.println(map);
    }

    @Test
    public void test8(){
        DoubleSummaryStatistics ds = employees.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(ds.getAverage());
        System.out.println(ds.getMax());
        System.out.println(ds.getCount());
    }

    @Test
    public void test8(){
        //把所有名字变成字符串
        String str = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining());
        System.out.println(str); //"张三李四王五赵六田七"

        String str1 = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",","===","==="));
        System.out.println(str1); //"===张三,李四,王五,赵六,田七==="
    }

Copyright © 2019- yule263.com 版权所有 湘ICP备2023023988号-1

违法及侵权请联系:TEL:199 1889 7713 E-MAIL:2724546146@qq.com

本站由北京市万商天勤律师事务所王兴未律师提供法律服务