Java 流计算例子

package com.yunjian.iac.test.stream;

import java.text.Collator;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;

/**
 * @Author: ysm
 * @Platform: Mac
 * @Date: 5:36 下午 2021/5/5
 *
 *
 * 现有5个用户
 * 1。 id必须是偶数
 * 2。 年龄必须大于23岁
 * 3。 用户名转大写
 * 4。 用户名倒序
 * 5。 只输出一个用户
 */
public class Test {

    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(5, "e", 25);
        User u6 = new User(6, "f", 26);

        // 1. 集合管存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5, u6);
//        list.forEach((u) -> System.out.println(u));

        /** 2. 计算交给流 */
        List<User> list1 = list.stream().filter((u) -> {return u.getId() % 2 == 0;}) // 过滤：Predicate接口，偶数
                .filter((u) -> {return u.getAge() >= 23;}) // 过滤：Predicate接口，大于23
                .map((u) -> { // 映射：Function接口，转换大小写(对集合里每一个元素都做加工)
                    u.setName(u.getName().toUpperCase());
                    return u;})
                .sorted((o1, o2) -> {return o2.getName().compareTo(o1.getName());}) // 倒序，Comparator接口
                .limit(1)
                .collect(Collectors.toList()); // 收集流里的元素转换成集合
                //.forEach(System.out :: println);

        list1.forEach((u) -> {
            System.out.println(u);
        });

        System.out.println("---------------");
        List<Long> list2 = Arrays.asList(1L, 2L, 3L, 4L, 5L, 4L);
        List<Long> list22 = list2.stream().distinct() // 去重
                .skip(2) // 跳过前面的2个元素
                .collect(Collectors.toList());
        list22.forEach((c) -> {
            System.out.println(c);
        });

        // 按照中文倒序
        List<String> list3 = Arrays.asList("赵", "前", "孙", "里");
        List<String> list31 = list3.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
        list31.forEach(System.out :: println);

        /**
         * 终止符
         * anyMatch：流中是否有满足条件的元素
         * allMatch: 所有元素都满足
         * noneMatch: 所有都不满足
         * findAny: 返回任意一个元素
          */

        List<String>list4 = Arrays.asList("赵", "前", "孙", "里");
        boolean rs4 = list4.stream().anyMatch((s) -> {return s.equals("前");});
        System.out.println(rs4);

        Optional<String> any = null;
        for(int i = 0; i < 10; i++) {
            // 并行parallel去findAny会得到不同的结果
            any = list4.stream().parallel().findAny();
            if(any.isPresent()) {
                System.out.println(any.get());
            }
        }

        /**
         * collect收集器，将流转换为其他形式
         */
        List<Long> list5 = Arrays.asList(1L, 2L, 3L, 2L);
        Set<Long> set5 = list5.stream().collect(Collectors.toSet());
        set5.forEach(System.out :: println);

        // list转map
        Map<Long, String> map5 = list5.stream()
                .collect(Collectors.toMap((key) -> {return key;},
                        (value) -> {return "value" + value;},
                        (oldvalue, newvalue) -> newvalue));
        map5.forEach((k, v) -> {
            System.out.println(k + " --- " + v);
        });

        /**
         * reduce：将流中所有元素反复结合起来，得到一个结果
         */
        List<String>list6 = Arrays.asList("abc", "bc", "bcf", "efg", "abcd", "bca", "jkf");
        // acc:保存计算结果
        // item: 集合里的元素
        // 看下reduce里面的参数，是个BiFunction
        // 一个参数
        Optional<String> reduce = list6.stream().reduce((acc, item) -> {

            return acc + item;
        });

        if(reduce.isPresent()) {
            System.out.println(reduce.get());
        }

        // 两个参数：第一个参数：赋值初始值。
        // 返回类型与初始值类型一致
        String reduce2 = list6.stream().reduce("初始值:", (acc, item) -> {
            return acc + item;
        });
        System.out.println(reduce2);

        System.out.println("--- 三个参数 ---");
        // 三个参数
        List<String> rs6 = list6.stream().reduce(
                new ArrayList<String>(),
                new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
                    @Override
                    public ArrayList<String> apply(ArrayList<String> acc, String item) {
                        acc.add(item);
                        return acc;
                    }
                },
                new BinaryOperator<ArrayList<String>>() {
                    @Override
                    public ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {
                        return acc;
                    }
                });
        rs6.forEach(System.out :: println);

    }
}