Java8 之Stream 详解

2019年6月20日 159次阅读来源: 第二庄

一. 什么是Stream

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

Stream有几个值得注意的地方：

①:Stream自己不会存储元素

②:Stream不会改变源对象。相反，它会返回一个持有结果的新Stream。

③:Stream操作是延迟的，它会等到需要结果的时候才执行。

二. Stream操作三步骤

1. 创建Stream

通过一个数据源(集合、数组)得到一个流

2. 中间操作

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

3. 终止操作(终端操作)

一个终止操作，执行中间操作链并产生结果

三. Stream 的创建

Stream的创建基本上可以说有四种方法：

可以通过Collection系列集合提供的stream() 或者 parallelStream()
通过Arrays中的静态方法stream()获取数组流
通过Stream类中的静态of()方法

创建无限流

“`

  /**
  * 创建Stream
  */
 @Test
 public void test1(){

     //1. 可以通过Collection系列集合提供的stream() 或者 parallelStream()

     Stream<String> stream1 = list.stream();

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

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

     //4. 创建无限流
     //迭代
     Stream<Integer> stream4 = Stream.iterate(0,x -> x*2);
     //生成器
     Stream<Double> stream5 = Stream.generate(Math::random);
 }

“`

四.Stream的中间操作

1.筛选与切片

①：filter — 接收lambda，从流中排除某些元素

②：limit — 截断流，使其元素不超过给定数量

③：skip — 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回空流。

④：distinct — 筛选，通过流所生成元素的hashCode()和equals()方法除重复元素

    /** * filter、limit、skip、distinct 等筛选及切片操作 */
    @Test
    public void test2(){
        // 中间操作 不会执行任何操作
        Stream<Student> stream1 = studentList.stream()
                                            .filter(student -> student.getAge()>22);

        // 终止操作 一次性执行全部内容 即"惰性求值"
        stream1.forEach(System.out::println);
// Student{id=12, name='lisi', age=23}
// Student{id=13, name='wangwu', age=24}
// Student{id=14, name='zhaoliu', age=25}

        studentList.stream()
                .filter(student -> student.getAge()>22)
                .limit(2)
                .forEach(System.out::println);
// Student{id=12, name='lisi', age=23}
// Student{id=13, name='wangwu', age=24}

        studentList.stream()
                .filter(student -> student.getAge()>22)
                .skip(2)
                .forEach(System.out::println);
// Student{id=14, name='zhaoliu', age=25}

        List<String> strList =Arrays.asList("aa","bb","cc","aa");
        strList.stream().distinct().forEach(System.out::println);
// aa
// bb
// cc
    }

2.映射

①：map — 接收一个函数作为参数，该函数会作用到每个元素上，并将其映射成一个新元素

②：flatMap — 接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流

     /** * map、flatMap等映射操作 */
    @Test
    public void test3(){
        List<String> strList =Arrays.asList("aa","bb","cc","aa");
        strList.stream().map(String::toUpperCase).forEach(System.out::print);
        // AABBCCAA
        studentList.stream().map(Student::getName).forEach(System.out::print);
        // zhangsanlisiwangwuzhaoliu

        // TestStream1 是方法所在的类名
        Stream<Stream<Character>> stream = strList.stream().map(TestStream1::toCharacter);
        stream.forEach(stre ->{
            stre.forEach(System.out::print);
        });
        // aabbccaa
        strList.stream().flatMap(TestStream1::toCharacter).forEach(System.out::print);
        // aabbccaa 此方法相当于上述操作的简写
    }

    private static Stream<Character> toCharacter(String str){
        List<Character> list =new ArrayList<>();
        for(Character chr : str.toCharArray()){
            list.add(chr);
        }
        return list.stream();
    }

3.排序

①：sorted() — 产生一个新流，其中按自然顺序排序

②：sorted(Comparator com) — 产生一个新流，其中按比较器顺序排序

    /** * sorted */
    @Test
    public void test4(){
        List<String> strList =Arrays.asList("bb","cc","aa");
        strList.stream().sorted().forEach(System.out::println);
        // aa
        // bb
        // cc
        studentList.stream().sorted(Comparator.comparing(Student::getName))
                                .forEach(System.out::println);
        //Student{id=12, name='lisi', age=23}
        //Student{id=13, name='wangwu', age=24}
        //Student{id=11, name='zhangsan', age=22}
        //Student{id=14, name='zhaoliu', age=25}
    }

五. Stream的终止操作

1. 查找与匹配

①：allMatch(Predicate p) — 检查是否匹配所有元素

②：anyMatch(Predicate p) — 检查是否至少匹配一个元素

③：noneMatch(Predicate p) — 检查是否没有匹配所有元素

④：findFirst() — 返回第一个元素

⑤：findAny() — 返回当前流中的任意元素

⑥：count() — 返回流中元素总数

⑦： max(Comparator c) — 返回流中最大值

⑧：min(Comparator c) — 返回流中最小值

⑨：forEach(Consumer c) — 内部迭代

    @Test
    public void test5() {
        // 所有学生的年龄都是22岁吗？
        boolean flag1 = studentList.stream().allMatch(s -> s.getAge() == 22);
        System.out.println(flag1); // false

        // 有学生的年龄是22岁吗
        boolean flag2 = studentList.stream().anyMatch(s -> s.getAge() ==22);
        System.out.println(flag2); // true

        // 是不是没有名字为tom的学生
        boolean flag3 = studentList.stream().noneMatch(s -> s.getName().equals("tom"));
        System.out.println(flag3); // true

        // 得到集合中的第一个元素
        Optional<Student> op1 = studentList.stream().findFirst();
        System.out.println(op1.get()); // Student{id=11, name='zhangsan', age=22}

        // 得到集合中任一元素
        Optional<Student> op2 = studentList.stream().findAny();
        System.out.println(op2.get()); // Student{id=11, name='zhangsan', age=22}

        // 一共有几个学生
        long count = studentList.stream().count();
        System.out.println(count); // 4

        //得到年龄最大的学生信息
        Optional<Student> op3= studentList.stream().max(Comparator.comparing(Student::getAge));
        System.out.println(op3.get()); // Student{id=14, name='zhaoliu', age=25}

        //得到年龄最小的学生信息
        Optional<Student> op4= studentList.stream().min(Comparator.comparing(Student::getAge));
        System.out.println(op4.get()); // Student{id=11, name='zhangsan', age=22}
    }

2. 规约

①：reduce(T identity, BinaryOperator accumulator) — identity为初始值，将流中元素反复结合起来，得到一个值。返回 T

②：Optional reduce(BinaryOperator accumulator) — 将流中元素反复结合起来，得到一个值。
返回 Optional

    @Test
    public void test6(){
        // 第一个reduce方法第一个参数代表赋予结果一个初始值，说明没有空指针的危险 故直接返回基础类型
        int age1 = studentList.stream().map(Student::getAge).reduce(0,(x, y) -> x+y); System.out.println(age1); // 94 // 第二个reduce方法没有初始值，为了避免空指针的危险，故返回 Optional 类型 Optional<Integer> age2 = studentList.stream().map(Student::getAge).reduce((x, y) -> x+y); System.out.println(age2.get()); // 94 }

3. 收集

①： toList — 把流中元素收集到List

②： toSet — 把流中元素收集到Set

③： toCollection — 把流中元素收集到创建的集合

④： counting — 计算流中元素的个数

⑤：summingInt — 对流中元素的整数属性求和

⑥：averagingInt — 计算流中元素Integer属性的平均值

⑦：maxBy — 根据比较器选择最大值

⑧： minBy — 根据比较器选择最小值

⑨：joining — 连接流中每个字符串

⑩：groupingBy — 根据某属性值对流分组，属性为K，结果为Map

    @Test
    public void test7(){
        // toList
        List<String> list = studentList.stream().map(Student::getName)
                                       .collect(Collectors.toList());
        list.forEach(System.out::print); // zhangsanlisiwangwuzhaoliu
        System.out.println("------------------------------------");
        // toSet
        Set<String> set = studentList.stream().map(Student::getName)
                                    .collect(Collectors.toSet());
        set.forEach(System.out::print); // lisizhaoliuzhangsanwangwu
        System.out.println("------------------------------------");
        // toCollection
        HashSet<String> hashSet = studentList.stream().map(Student::getName)
                            .collect(Collectors.toCollection(HashSet::new));
        hashSet.forEach(System.out::print); // lisizhaoliuzhangsanwangwu
    }

    @Test
    public void test8(){
        // 总数
        long count = studentList.stream().collect(Collectors.counting());
        System.out.println(count);  // 4

        // 平均值
        double ave = studentList.stream().collect(Collectors.averagingInt(Student::getAge));
        System.out.println(ave);  // 23.5

        //总和
        int sum = studentList.stream().collect(Collectors.summingInt(Student::getAge));
        System.out.println(sum);  // 94

        //最大值
        Optional<Integer> max = studentList.stream().map(Student::getAge)
                                        .collect(Collectors.maxBy(Integer::compare));
        System.out.println(max.get());  // 25

        // 最小值
        Optional<Integer> min = studentList.stream().map(Student::getAge)
                .collect(Collectors.minBy(Integer::compare));
        System.out.println(min.get());  // 22

        // 分组
        Map<Integer,List<Student>> map = studentList.stream().collect(Collectors.
                                        groupingBy(Student::getAge));
        System.out.println(map);
        // {22=[Student{id=11, name='zhangsan', age=22}, Student{id=15, name='liuqi', age=22}],
        // 23=[Student{id=12, name='lisi', age=23}],
        // 24=[Student{id=13, name='wangwu', age=24}],
        // 25=[Student{id=14, name='zhaoliu', age=25}]}

        String str = studentList.stream().map(Student::getName)
                                .collect(Collectors.joining(","));
        System.out.println(str);  // zhangsan,lisi,wangwu,zhaoliu,liuqi
    }

    原文作者：第二庄
    原文地址: https://blog.csdn.net/liujun03/article/details/81117548
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。