Java Stream

 

 

list.stream() 创建顺序流

list.parallelStream() 创建并行流

Arrays.stream(数组)

Stream.of(数组)

通过parallel()把顺序流转换成并行流

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

 

Stream的使用

Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

 

 

package com.stream;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 15,"male", "New York"));
        personList.add(new Person("Jack", 7000, 16,"male", "Washington"));
        personList.add(new Person("Lily", 7800, 17,"female", "Washington"));
        personList.add(new Person("Anni", 8200, 18,"female", "New York"));
        personList.add(new Person("Owen", 9500, 19,"male", "New York"));
        personList.add(new Person("Alisa", 7900, 20,"female", "New York"));

        /*=============================遍历/匹配（foreach/find/match）==================         */
        List<Integer> list  = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
        // 遍历输出符合条件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();
        System.out.println("配第一个" + first.get());
        // 匹配任意（适用于并行流）
        Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        System.out.println("匹配任意一个值：" + findAny.get());
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(s -> s < 6);
        System.out.println("anyMatch : " + anyMatch);

        //============== 筛选（filter）================================================

        //筛选出Integer集合中大于7的元素
        list.stream().filter(s -> s > 7).forEach(System.out::println);
        //筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集）
        personList.stream().filter(s -> s.getSalary() > 8000).map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);

        //============================== 聚合（max/min/count)====================================

        //获取String集合中最长的元素。
        List<String> listStr = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
        Optional<String> strMax = listStr.stream().max(Comparator.comparing(String::length));
        System.out.println("最长" + strMax.get());

        //获取Integer集合中的最大值
        // 自然排序
        Optional<Integer> intMax = list.stream().max(Integer::compareTo);
        //自定义
        Optional<Integer> intMax02 = list.stream().max(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(intMax.get());
        System.out.println(intMax02.get());


        //获取员工工资最高的人
        Optional<Person> salMax = personList.stream().max(Comparator.comparing(Person::getSalary));
        System.out.println("工资最高的人"+salMax.get().getSalary());

        //计算Integer集合中大于6的元素的个数
        long count = list.stream().filter(s -> s > 6).count();
        System.out.println("个数"+count);

        //=====================映射(map/flatMap)======================================
        //映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap
        //map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        //flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流


        //英文字符串数组的元素全部改为大写。整数数组每个元素+3
        String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
        Arrays.stream(strArr).map(s -> s.toUpperCase()).collect(Collectors.toList()).forEach(System.out::println);
        list.stream().map(s -> s+3).collect(Collectors.toList());

        //将员工的薪资全部增加1000。
        // 不改变原来员工集合的方式
        List<Person> personListNew = personList.stream().map(person -> {
            Person personNew = new Person(person.getName(), 0, 0, null, null);
            personNew.setSalary(person.getSalary() + 1000);
            return personNew;
        }).collect(Collectors.toList());
        System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
        System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());

        // 改变原来员工集合的方式
        List<Person> personListNew2 = personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 1000);
            return person;
        }).collect(Collectors.toList());
        System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
        System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew2.get(0).getSalary());

        //将两个字符数组合并成一个新的字符数组
        List<String> listArr = Arrays.asList("m-k-l-a", "1-3-5-7");
        List<String> listArrNew = listArr.stream().flatMap(s -> {
            // 将每个元素转换成一个stream
            String[] split = s.split("-");
            Stream<String> stream = Arrays.stream(split);
            return stream;
        }).collect(Collectors.toList());

        System.out.println("处理前的集合：" + listArr);
        System.out.println("处理后的集合：" + listArrNew);

        //=================================归约(reduce)=================================
        //归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

        //求Integer集合的元素之和、乘积和最大值
        // 求和方式1
        Optional<Integer> sum01 = list.stream().reduce((x, y) -> x + y);
        //求和方式2
        Optional<Integer> sum02 = list.stream().reduce(Integer::sum);
        //求和方式3
        Integer sum03 = list.stream().reduce(0, Integer::sum);

        // 求乘积
        Optional<Integer> product  = list.stream().reduce((x, y) -> x * y);

        // 求最大值方式1
        Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);

        //求最大值写法2
        Integer max02 = list.stream().reduce(1, Integer::max);

        System.out.println("总和" + sum01.get() + "," + sum02.get() + "," + sum03);
        System.out.println("乘积" + product.get());
        System.out.println("最大值" + max.get() +  ", 最大值" + max02);


        //求所有员工的工资之和和最高工资
        //所有员工的工资之和
        Optional<Integer> s1 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
        Integer s2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
        // 求最高工资方式
        Integer high = personList.stream().map(Person::getSalary).reduce(1, Integer::max);

        System.out.println("和："+s1.get() + "=======" + s2 );
        System.out.println("高："+ high);

        //===========================收集(collect)==================================
        //把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合
        //归集(toList/toSet/toMap)
        //toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

        list.stream().filter(s -> s>6).collect(Collectors.toList()).forEach(System.out::println);
        list.stream().filter(s -> s % 3 == 0).collect(Collectors.toSet()).forEach(System.out::println);

        Map<String, Person> collect = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
        for (String s : collect.keySet()) {
            System.out.println(s);
        }
        System.out.println(collect);

        //==============================统计(count/averaging)==========================
        /*
            Collectors提供了一系列用于数据统计的静态方法：
            计数：count
            平均值：averagingInt、averagingLong、averagingDouble
            最值：maxBy、minBy
            求和：summingInt、summingLong、summingDouble
            统计以上所有：summarizingInt、summarizingLong、summarizingDouble
         */
        //统计员工人数、平均工资、工资总额、最高工资。
        // 求总数
        Long count01 = personList.stream().collect(Collectors.counting());
        // 求平均工资
        Double aveSal = personList.stream().collect(Collectors.averagingInt(Person::getSalary));
        // 求最高工资
        Optional<Integer> salMax02  = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
        //求工资之和
        Optional<Integer> he = personList.stream().map(Person::getSalary).collect(Collectors.reducing((x, y) -> x + y));
        // 一次性统计所有信息
        DoubleSummaryStatistics countCollect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));


        System.out.println(count01);
        System.out.println(aveSal);
        System.out.println(salMax02.get());
        System.out.println(he.get());
        System.out.println(countCollect);


        //==============================================分组(partitioningBy/groupingBy)========================
        //分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
        //分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

        //将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
        Map<Boolean, List<Person>> fenZuBySal = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        Map<String, List<Person>> fenZuBySex = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> fenZu = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));

        System.out.println(fenZuBySex);
        System.out.println(fenZu);
        //=====================================接合(joining)=======================
        //joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串
        String joinTest = personList.stream().map(p -> p.getName()).collect(Collectors.joining("--"));
        System.out.println(joinTest);
        //=========================归约(reducing)==================================
        //Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。

        // 每个员工减去起征点后的薪资之和
        Integer sum = personList.stream().collect(Collectors.reducing(1, Person::getSalary, (i, j) -> (i + j - 5000)));
        System.out.println("员工扣税薪资总和：" + sum);

        //stream的reduce
        Optional<Integer> reduceSum =personList.stream().map(Person::getSalary).reduce(Integer::sum);
        System.out.println("员工薪资总和：" + reduceSum.get());


        //================================================3.7 排序(sorted)===============================
        //sorted，中间操作。有两种排序：
        //sorted()：自然排序，流中元素需实现Comparable接口
        //sorted(Comparator com)：Comparator排序器自定义排序


        //将员工按工资由高到低（工资一样则按年龄由大到小）排序
        // 按工资增序排序
        List<String> sortBySalIncr = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
        // 按工资倒序排序
        List<String> sortBySalDecr = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
        // 先按工资再按年龄自然排序（升序）


        // 先按工资再按年龄自然排序（降序）
        List<String> salAndAgeDesc = personList.stream().sorted((p1, p2) -> {
            if (p1.getSalary() == p2.getSalary()) {
                return p2.getSalary() - p1.getSalary();
            }
            return p2.getSalary() - p1.getSalary();

        }).map(Person::getName).collect(Collectors.toList());

        System.out.println("先按工资再按年龄自定义降序排序：" + salAndAgeDesc);

        //===============================提取/组合==============================================

        String[] arr1 = { "a", "b", "c", "d" };
        String[] arr2 = { "d", "e", "f", "g" };

        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);

        // concat:合并两个流 distinct：去重
        List<String> concatAndDistinct = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        //limit：限制从流中获得前n个数据
        List<Integer> limitStream = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
        //skip：跳过前n个数据
        List<Integer> skipStream = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());


        System.out.println("流合并：" + concatAndDistinct);
        System.out.println("limit：" + limitStream);
        System.out.println("skip：" + skipStream);


    }
}