场景

Java 8扩展了集合类，可以通过 Collection.stream()或者 Collection.parallelStream()来创建一个Stream。

利用Stream，在对集合比如list进行处理时就不用再进行繁琐的循环遍历操作了。

比如：

遍历一个对象list并输出每个的年龄属性

userList.stream().filter(user -> user.getAge() > 40).forEach(item -> System.out.println(item.getAge()));

注：

博客：
https://blog.csdn.net/badao_liumang_qizhi
关注公众号
霸道的程序猿
获取编程相关电子书、教程推送与免费下载。

实现

一、Stream的创建

有3种方法，示例代码如下

        //1、通过java.util.Collection.stream()方法用集合创建流
        List<String> list = Arrays.asList("zhansan","lisi","wangwu");
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);
        //2、通过java.util.Arrays.stream(T[]array)方法用数组创建流
        String[] array = {"zhansan","lisi","wangwu"};
        Stream<String> stream2 = Arrays.stream(array);
        stream2.forEach(System.out::println);
        //3、使用Stream的静态方法:of() iterate() generate()
        Stream<Integer> stream3 = Stream.of(1,2,3);
        stream3.forEach(System.out::println);
        Stream<Integer> stream4 = Stream.iterate(0,(x->x+3)).limit(4);
        stream4.forEach(System.out::println);
        //双冒号运算操作符是类方法的句柄，lambda表达式的一种简写。双冒号（::）运算符在Java 8中被用作方法引用（method reference）
        //这种[方法引用]或者说[双冒号运算]对应的参数类型是Function<T,R>T表示传入类型，R表示返回类型。比如表达式person->person.getAge();
        // 传入参数是person，返回值是person.getAge() 可替换成Person::getAge
        Stream<Double> stream5 = Stream.generate(Math::random).limit(3);
        stream5.forEach(System.out::println);

二、常用API

1、首先创建并构造对象list

新建User对象

package com.ruoyi.demo.domain;

public class User {
    private  String name;
    private  int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

然后构造userlist

private static List<User> userList = new ArrayList<User>();

        //创建User集合
        userList.add(new User("霸道",30));
        userList.add(new User("的",40));
        userList.add(new User("程序猿",50));
        userList.add(new User("张三",60));
        userList.add(new User("李四",70));

2、过滤filter和遍历forEach

        //api的使用-过滤filter和遍历forEach
        //userList.stream().filter(user -> user.getAge() > 40).forEach(item -> System.out.println(item.getAge()));

如果筛选条件是多个，比如筛选年龄介于40到70之间

        //多个筛选，少选年龄介于40到70之间
        //userList.stream().filter(user -> user.getAge() > 40 && user.getAge() < 70).forEach(item -> System.out.println(item.getAge()));

3、匹配第一个findFirst

        //匹配第一个findFirst
        //System.out.println("匹配第一个findFirst:"+userList.stream().filter(user ->user.getAge()<60).findFirst().get().getName());

4、是否包含符合特定条件的元素anyMatch

        //是否包含符合特定条件的元素anyMatch
        //System.out.println("是否包含年龄大于80的元素:"+userList.stream().anyMatch(user -> user.getAge()>80));

5、按条件筛选特定条件的元素

        //按条件筛选并形成新的集合collect(Collectors.toList())
        //userList.stream().filter(user -> user.getAge() > 40).collect(Collectors.toList()).forEach(item->System.out.println(item.getAge()));

6、聚合max、min、count

        //聚合max min count
        //获取User中年龄最大的，最小的同理
        //Comparator<User> comparator = Comparator.comparing(User::getAge);
        //System.out.println("聚合max,年龄最大的是："+userList.stream().max(comparator).get().getAge());
        //获取年龄大于40的个数
        //System.out.println("年龄大于40的个数是："+userList.stream().filter(x ->x.getAge()>40).count());

7、map与flatmap

        //map 与 flatmap
        //map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        //给每个User的年龄加10 注意此时后面再次forEach的时候，每个item代表的是age,则不再是user了
        //userList.stream().map(user -> user.getAge() + 10).collect(Collectors.toList()).forEach(item -> System.out.println(item));
        //另外除了map之外还有一个flatmap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

8、reduce缩减，求和、求积、求最值

        //规约reduce 把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        //求和
        //Optional<Integer> reduceAdd = list.stream().reduce((x, y)->x+y);
        //求乘积
        //Optional<Integer> reduceMul = list.stream().reduce((x, y)->x*y);
        //求最大值
        Optional<Integer> reduceMax = list.stream().reduce((x, y)->x>y?x:y);
        //System.out.println(reduceMax.get());

9、收集toList、toSet、toMap

        //收集 toList toSet toMap
        //年龄大于50的User转换成map
        Map<String,User> map = userList.stream().filter(user -> user.getAge()>50).collect(Collectors.toMap(User::getName,y->y));
        //System.out.println(map);

10、Collectors提供了一系列的用于数据统计的静态方法

        //Collectors提供了一系列用于数据统计的静态方法
        //计数
        //System.out.println(userList.stream().collect(Collectors.counting()));
        //求平均值
        //System.out.println(userList.stream().collect(Collectors.averagingInt(User::getAge)));
        //求和
        //System.out.println(userList.stream().collect(Collectors.summingInt(User::getAge)));
        //一次性统计所有(计数、求和、求平均、最大值、最小值)
        //System.out.println(userList.stream().collect(Collectors.summarizingInt(User::getAge)));

11、分组

        //分组
        //按照年龄是否大于50进行分组
        Map<Boolean,List<User>> userPart = userList.stream().collect(Collectors.partitioningBy(user -> user.getAge()>50));
        //System.out.println(userPart);
        //按照年龄进行分组
        Map<Integer,List<User>> userGroup = userList.stream().collect(Collectors.groupingBy(User::getAge));
        //System.out.println(userGroup);

12、连接

       //连接joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
        String nameString = userList.stream().map(user -> user.getName()).collect(Collectors.joining("和"));
        //System.out.println(nameString);

13、排序

        //排序sorted
        //按照年龄升序排序
        //System.out.println(userList.stream().sorted(Comparator.comparing(User::getAge)).map(User::getAge).collect(Collectors.toList()));
        //按照年龄降序排序
        //System.out.println(userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).map(User::getAge).collect(Collectors.toList()));

14、提取、组合

        //提取、组合
        String[] arr = {"1","2","3","4"};
        String[] arr1 = {"3","4","5","6"};
        Stream<String> stream = Stream.of(arr);
        Stream<String> stream1 = Stream.of(arr1);
        //concat合并两个流
        //List<String> collect = Stream.concat(stream, stream1).collect(Collectors.toList());
        //System.out.println(collect);
        //distinct去重
        //List<String> collect1 = Stream.concat(stream, stream1).distinct().collect(Collectors.toList());
        //System.out.println(collect1);

15、限制

        //限制从流中获取前n个数据
        //System.out.println(Stream.iterate(1,x -> x+2).limit(5).collect(Collectors.toList()));
        //skip 跳过前n个数据
        System.out.println(Stream.iterate(1,x -> x+2).skip(5).limit(5).collect(Collectors.toList()));