java8新特性stream的使用

Stream的使用

• 遍历/匹配—find/foreach/match
• 筛选—filer
• 聚合—max/min/count
• 映射—map/flatmap
• 归约—reduce
• 统计—count/averaging
  • 计数:count
  • 平均值:averagingInt,averagingDouble,averagingLong
  • 最值:maxBy,minBy
  • 求和:summingInt,summingDouble,summingLong
  • 统计以上所有:summarizingInt,summarizingLong,summarizingDouble
• 分组—partitioningBy/groupingBy
• 接合—joining
• 排序—sorted
• 提取/组合：合并/去重/限制/跳过—distinct/limit/skip

import com.example.demo.entity.Person;

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

public class StreamTestAll {

    public static void main(String[] args) {
        tq();
    }

    /**
     * 遍历/匹配/
     * find/foreach/match
     */
    public static void test() {
        List<Integer> list = Arrays.asList(1, 9, 8, 6, 7, 5);
        //遍历输出符合条件的元素--简写（x-> System.err.println(x) --System.err::println）
        list.stream().filter(x -> x > 6).forEach(System.err::println);
        //匹配第一个
        Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();
        //匹配任意（适用于并行流）
        Optional<Integer> any = list.stream().filter(x -> x > 6).findAny();
        //是否包含符合特定条件的元素
        boolean b = list.stream().anyMatch(z -> z > 6);
        System.err.println("匹配第一个值" + first.get());
        System.err.println("匹配任意一个值" + any.get());
        System.err.println("是否存在大于6的值" + b);
    }

    /**
     * 筛选 filer
     * 按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作
     * 1.筛选出数组中大于7的元素
     */
    public static void filterOne() {
        List<Integer> list = Arrays.asList(1, 8, 9, 10, 5, 6, 7);
        list.stream().filter(x -> x > 7).forEach(System.err::println);
    }

    /**
     * 筛选 filer
     * 按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作
     * 2. 筛选员工中工资高于8000的人
     */
    public static void filterTwo() {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        List<String> collect = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
        System.err.println("薪资大于8000的人" + collect);
    }

    /**
     * 聚合
     * max/min/count
     * 获取String集合中最长的元素//yellow
     */
    public static void fileterThree() {
        List<String> strings = Arrays.asList("apple", "yellow", "banana");
        Optional<String> max = strings.stream().max(Comparator.comparing(String::length));
        System.err.println("最长的元素" + max.get());
    }

    /**
     * 聚合
     * max/min/count
     * 获取Integer集合中最大的元素
     */
    public static void fileterFour() {
        List<Integer> strings = Arrays.asList(1001, 10, 99, 5, 1000);
        //自然排序
        Optional<Integer> max = strings.stream().max(Integer::compareTo);
        //自定义排序
        Integer integer = strings.stream().max(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        }).get();

        //简写.max((o1, o2) -> o1 - o2)，更简写Comparator.comparingInt(o -> o)
        Integer integer2 = strings.stream().max(Comparator.comparingInt(o -> o)).get();
        System.err.println("最大的元素" + max.get());
        System.err.println("最大的元素" + integer);
        System.err.println("最大的元素" + integer2);
    }

    /**
     * 聚合
     * max/min/count
     * 获取员工工资中薪资最高的人
     */
    public static void fileterFive() {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
        System.err.println(
                "员工工资最高的人" + max.get()
        );
    }

    /**
     * 聚合
     * max/min/count
     * 计算integer集合中大于6的个数
     */
    public static void fileterSix() {
        List<Integer> list = Arrays.asList(9, 8, 7, 6, 78, 89);
        long count = list.stream().filter(x -> x > 6).count();
        System.err.println("大于6的个数" + count);
    }

    /**
     * 映射
     * map/flatmap
     * 可以将一个流的元素按照一定的规则映射到另一个集合中
     * map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     * flatmap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流
     * 例题:英文字符串数组的元素全部改为大写。整数数组每个元素+3。
     */
    public static void fileterSeven() {

        List<String> list = Arrays.asList("ab", "fg", "er");
        List<String> collect = list.stream().map(String::toUpperCase).collect(Collectors.toList());
        System.err.println("英文字符串改为大写" + collect.toString());

        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> collect1 = integerList.stream().map(x -> x + 3).collect(Collectors.toList());
        System.err.println("整数数组元素" + collect1.toString());

    }

    /**
     * 将所有员工的薪资全部增加1000
     */
    public static void fileterEight() {
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        List<Integer> collect = personList.stream().map(x -> x.getSalary() + 1000).collect(Collectors.toList());
        System.err.println("全部薪资加1000" + collect.toString());


        //不改变原来员工集合的方式
        List<Person> peopleOne = 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.err.println("一次改动前" + personList.get(0).getName() + "--->" + personList.get(0).getSalary());
        System.err.println("一次改动后" + peopleOne.get(0).getName() + "--->" + peopleOne.get(0).getSalary());
        List<Person> personLTwo = personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 1000);
            return person;
        }).collect(Collectors.toList());
        System.err.println("二次改动前" + personList.get(0).getName() + "--->" + personList.get(0).getSalary());
        System.err.println("二次改动后" + personLTwo.get(0).getName() + "--->" + personLTwo.get(0).getSalary());
    }

    /**
     * 将两个字符数组合并成一个新的数组
     */
    public static void fileterNine() {
        List<String> list = Arrays.asList("a,b", "1,2,3,4", "a,d");
        List<String> collect = list.stream().flatMap(s -> {
            String[] split = s.split(",");
            Stream<String> stream = Arrays.stream(split);
            return stream;
        }).collect(Collectors.toList());
        //[a,b, 1,2,3,4, a,d]
        System.err.println("处理前的" + list);
        //[a, b, 1, 2, 3, 4, a, d]
        System.err.println("处理后的" + collect);
    }

    /**
     * reduce (归约也称：缩减),就是把一个流缩减成一个值，能够实现对集合求和，求乘积等操作
     * 求Integer集合的元素之和，乘积和最大值
     */
    public static void reduceOne() {
        List<Integer> list = Arrays.asList(1, 5, 6, 9, 8);
        //求和1
        Optional<Integer> sum1 = list.stream().reduce((x, y) -> x + y);
        //求和2
        Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
        //求和3
        Integer sum3 = list.stream().reduce(0, Integer::sum);

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

        //求最大值1
        Optional<Integer> maxOne = list.stream().reduce((x, y) -> x > y ? x : y);
        //求最大值2
        //T reduce(T identity, BinaryOperator<T> accumulator);
        //给定一个初始值identity，通过累加器accumulator迭代计算，得到一个同Stream中数据同类型的结果
        Integer maxTwo = list.stream().reduce(1, Integer::max);
        Integer maxThere = list.stream().reduce(0, Integer::max);

        System.err.println("求和1:" + sum1.get() + "求和2:" + sum2.get() + "求和3:" + sum3);
        System.err.println("求乘积:" + product.get());
        System.err.println("求最大值1:" + maxOne.get() + "求最大值2:" + maxTwo + "bzdss:" + maxThere);
    }

    /**
     * 求所有员工的工资之和和最高工资
     */
    public static void reduceTwo() {
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        //求工资之和方式1
        Optional<Integer> reduce = personList.stream().map(Person::getSalary).reduce(Integer::max);
        //求工资之和方式2
        Integer sum3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), (sum1, sum2) -> sum1 + sum2);
        // 求工资之和方式3：
        Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);

        // 求最高工资方式1：
        Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
                Integer::max);
        // 求最高工资方式2：
        Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
                (max1, max2) -> max1 > max2 ? max1 : max2);

        System.err.println("最大值：" + reduce.get());
        Optional<Integer> sum = personList.stream().map(Person::getSalary).reduce(Integer::sum);
        System.err.println("sum:" + sum.get());
    }

    /**
     * 收集,把一个收集起来,最终可以收集成一个值也可以收集成一个新的集合
     * 主要依赖于java.util.stream.Collectors类内置的静态方法
     */
    public static void collectOne() {
        //toList,toSet,toMap
        List<Integer> list = Arrays.asList(1, 3, 6, 9, 8, 5, 4, 6, 8);
        //list结果[6, 8, 4, 6, 8]
        List<Integer> integerList = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
        //set去重：结果[4, 6, 8]
        Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
        System.err.println(integerList);
        System.err.println(set);

        List<Person> pList = new ArrayList<>();
        pList.add(new Person("Tom", 8900, 23, "male", "New York"));
        pList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        pList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        pList.add(new Person("Anni", 8200, 24, "female", "New York"));

        Map<String, Person> map = pList.stream().filter(x -> x.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
        System.err.println(map);
    }

    /**
     * 统计(count/averaging)
     * 计数:count
     * 平均值:averagingInt,averagingDouble,averagingLong
     * 最值:maxBy,minBy
     * 求和:summingInt,summingDouble,summingLong
     * 统计以上所有:summarizingInt,summarizingLong,summarizingDouble
     */
    public static void countOne() {
        //统计员工人数，平均工资，工资总额，最高工资
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        //求员工总数
        Long count = personList.stream().collect(Collectors.counting());
        //求平均工资
        Double avgSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
        //求最高工资
        Optional<Integer> maxSalary = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
        //求工资之和
        Double sumSalary = personList.stream().collect(Collectors.summingDouble(Person::getSalary));
        //简化版
        double sum2Salary = personList.stream().mapToDouble(Person::getSalary).sum();
        //一次性统计所有的信息
        //结果:DoubleSummaryStatistics{count=3, sum=23700.000000, min=7000.000000, average=7900.000000, max=8900.000000}
        DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

        System.err.println("员工总数:" + count);
        System.err.println("平均工资:" + avgSalary);
        System.err.println("最高工资:" + maxSalary.get());
        System.err.println("工资之和:" + sumSalary);
        System.err.println("工资之和2:" + sum2Salary);
        System.err.println("员工工资所有统计:" + collect);
    }

    /**
     * 分组partitioningBy/groupingBy
     * 分区:将stream按条件分成两个map，比如按照员工薪资是否高于8000分为两部分
     * 分组:将集合分为多个map，比如员工按照性别分组。有年级分组和多级分组
     * 1.将员工按照薪资是否高于8000分为两部分。
     * 2.将员工按照性别和地区分组
     */
    public static void groupOne() {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Tom", 8900, "male", "New York"));
        personList.add(new Person("Jack", 7000, "male", "Washington"));
        personList.add(new Person("Lily", 7800, "female", "Washington"));
        personList.add(new Person("Anni", 8200, "female", "New York"));
        personList.add(new Person("Owen", 9500, "male", "New York"));
        personList.add(new Person("Alisa", 7900, "female", "New York"));
        Map<Boolean, List<Person>> collect = personList.stream().collect(Collectors.partitioningBy(p -> p.getSalary() > 8000));
        Map<String, List<Person>> sexCollect = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        Map<String, Map<String, List<Person>>> sexAndArea = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.err.println("按照薪资分：" + collect.toString());
        System.err.println();
        System.err.println("按照性别分：" + sexCollect);
        System.err.println();
        System.err.println("按照性别和地区分" + sexAndArea.toString());
    }

    /**
     * 接合(joining)
     * 可以将stream中的元素用特定的连接符(没有的话直接连接),连接成一个字符串
     */
    public static void groupTwo() {
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        String collect = personList.stream().map(Person::getName).collect(Collectors.joining(","));
        System.err.println("连接起来的name:" + collect);
        List<String> strings = Arrays.asList("12", "56", "89");
        String collect1 = strings.stream().collect(Collectors.joining("-"));
        System.err.println("拼接后的字符串" + collect1);
    }

    /**
     * 归约:reducing
     * Collectors提供的reducing,比stream的reduce增加了自定义归约的支持
     */
    public static void reducingOne() {

        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

        //每个员工减去起征点后的薪资之和
        Integer sum1 = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
        //简写后的
        Integer collect2 = personList.stream().map(Person::getSalary).reduce(0, (i, j) -> (i + j - 5000));
        //stream的reduce
        Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);

        System.err.println("扣税薪资总和" + sum1);
        System.err.println("全部薪资总和" + sum2);
    }

    /**
     * 排序sorted:中间操作
     * 1.sorted() 自然排序，流中元素需实现Comparable接口
     * 2.sorted(Comparator com)Comparator排序器自定义排序
     * 将员工按照工资由高到低(工资一样按照年龄由大到小)
     */
    public static void sortOne() {

        List<Person> personList = new ArrayList<Person>();

        personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
        personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
        personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 8800, 26, "male", "New York"));
        personList.add(new Person("Alisa", 9000, 26, "female", "New York"));

        //按照工资升序排序(自然排序)
        List<Integer> collect = personList.stream().map(Person::getSalary).sorted().collect(Collectors.toList());
        System.err.println(collect);

        //按照工资升序排序(自然排序)[Lily, Tom, Sherry, Jack, Alisa]
        List<String> sortOne = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
        System.err.println("升序排序" + sortOne);
        //按工资倒叙排序[Sherry, Jack, Alisa, Tom, Lily]
        List<String> sortTwo = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
        System.err.println("倒叙排序" + sortTwo);
        //先按照工资在按照年龄排序[Lily, Tom, Sherry, Jack, Alisa]
        List<String> sortThere = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());
        System.err.println("先按照工资在按照年龄:" + sortThere);
        //先按工资，在按年龄自定义排序（降序）[Alisa, Jack, Sherry, Tom, Lily]
        List<String> sortFour = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge).reversed()).map(Person::getName).collect(Collectors.toList());
        System.err.println("先按照工资在按照年龄降序" + sortFour);
    }

    /**
     * 提取/组合
     * 流也可以进行合并，去重，限制，跳过等
     */
    public static void tq() {

        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> distinct = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        System.err.println("合并并去重:" + distinct);
        //限制从流中获取前n个数据
        List<Integer> limit = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
        System.err.println("截取数据" + limit);
        //skip 跳过前几条数据
        List<Integer> skip = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
        System.err.println("跳过数据" + skip);
    }


}