Java8 stream：一文彻底搞懂stream流的全部用法

话不多说直接上代码

先建一个实体类

  class Person {
        private String name;  // 姓名
        private int salary; // 薪资
        private int age; // 年龄
        private String sex; //性别
        private String area;  // 地区

        // 构造方法
        public Person(String name, int salary, int age, String sex, String area) {
            this.name = name;
            this.salary = salary;
            this.age = age;
            this.sex = sex;
            this.area = area;
        }

        public String getName() {
            return name;
        }

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

        public int getSalary() {
            return salary;
        }

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

        public int getAge() {
            return age;
        }

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

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public String getArea() {
            return area;
        }

        public void setArea(String area) {
            this.area = area;
        }
    }

下面是所有的stream流相关的操作

 List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom",8900,18,"male","New York"));
        personList.add(new Person("Jack",7000,19,"male","Washington"));
        personList.add(new Person("Lily",7800,20,"female","Washington"));
        personList.add(new Person("Anni",8200,30,"female","New York"));
        personList.add(new Person("Owen",9500,18,"male","New York"));
        personList.add(new Person("Alisa",7900,23,"female","New York"));

        //匹配条件并输出
        personList.parallelStream().filter(s -> s.getAge() > 19).forEach(System.out::println);
        Optional<Person> optionalPerson = personList.stream().filter(s -> s.getAge() > 20).findFirst();
        Optional<Person> optionalPerson1 = personList.parallelStream().filter(s -> s.getAge() > 21).findAny();

//        Object a=hrRightService.getAllDataScope("1");
        //流的种类有顺序流和并行流
        //1.顺序流
        Stream<Person> stream = personList.stream();
        //2,并行流数据量大是提示效率
        Stream<Person> stream1 = personList.parallelStream();
        Stream<Person> stream2 = personList.stream().parallel();
        //遍历stream流
        personList.stream().forEach(System.out::println);
        //获取员工工资最高的人
        Optional<Person> maxOptional = personList.stream().max(Comparator.comparing(Person::getSalary));
        System.out.println("工资最高的人员" + JsonUtil.toJson(maxOptional));
        //计算工资大于8000的员工个数
        long count = personList.stream().filter(e->e.getSalary()>8000).count();
        System.out.println("计算工资大于8000的员工个数" + count);
        //去除元素中重复的值
        List<Integer> personList1 = personList.stream().distinct().map(Person::getAge).collect(Collectors.toList());
        System.out.println("去除元素中重复的值" + JsonUtil.toJson(personList1));
        //筛选
        List<String> engNameList = personList.stream().filter(e -> e.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
        System.out.println("员工工资高于8000的人员名字列表" + JsonUtil.toJson(engNameList));
        //映射
        //把sex中英文字符串数组的元素全部改为大写。(这里相当于把这个sex元素变成了字符串类型可以调用String的任何方法
        List<String> sexList = personList.stream().map(e -> e.getSex().toUpperCase()).collect(Collectors.toList());
        System.out.println("把sex中英文字符串数组的元素全部改为大写" + JsonUtil.toJson(sexList));
        //年龄整都整体+3岁。
        List<Integer> ageList = personList.stream().map(e->e.getAge()+3).collect(Collectors.toList());
        System.out.println("年龄整都整体+3岁。" + JsonUtil.toJson(ageList));
        //list转map用名字作为key
        Map<String, Person> map = personList.stream().collect(Collectors.toMap(Person::getName, person -> person));
        System.out.println("list转map的结果" + JsonUtil.toJson(map));
        //list转set
        Set<Person> peopleSet = personList.stream().collect(Collectors.toSet());
        //list条件筛选工资大于8000的人生成新的map
        Map<String, Person> maps = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
        System.out.println("list条件筛选工资大于8000的人生成新的map" + JsonUtil.toJson(maps));
        //将名字和工作地合并成一起生成新的字符串
        List<String> nameWorkList = personList.stream().map(e -> e.getName() + e.getArea()).collect(Collectors.toList());
        System.out.println("将名字和工作地合并成一起生成新的字符串" + JsonUtil.toJson(nameWorkList));
        //分组
        //按照员工薪资高于8000的分组
        Map<Boolean, List<Person>> map1 = personList.stream().collect(Collectors.partitioningBy(e -> e.getSalary() > 8000));
        //按员工性别分组
        Map<String, List<Person>> map2 = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        //员工先按性别再按照地区分组
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        //接合(joining)函数
        String engName = personList.stream().map(Person::getName).collect(Collectors.joining(","));
        System.out.println("所有的名字拼接在一起生成新的字符串" + engName);
        //排序按照工资自然排序
        List<Person> sortList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).collect(Collectors.toList());
        //排序按照工资倒序排序
        List<Person> sortList1 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).collect(Collectors.toList());
        //排序
        //提取组合
        //Collectors提供了一系列用于数据统计的静态方法：
        //
        //计数：count
        //平均值：averagingInt、averagingLong、averagingDouble
        //最值：maxBy、minBy
        //求和：summingInt、summingLong、summingDouble
        //统计以上所有：summarizingInt、summarizingLong、summarizingDouble
        // 求总数
        Long count1 = personList.stream().collect(Collectors.counting());
        // 求平均工资
        Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
        // 求最高工资
        Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
        // 求工资之和
        Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
        // 一次性统计所有信息
        DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
        //遍历多重list取出子list集合
        List<List<Person>> personLists = new ArrayList<List<Person>>();
        personLists.add(personList);
        List<Person> = personLists.stream()
        .flatMap(person-> person.stream())
        .collect(Collectors.toList());