1String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
2Arrays.sort(array,(o1,o2)->o2.compareTo(o1));

1public static void main(String[] args) {
2    String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
3    Arrays.sort(array, Main::cmp);
4}
5
6// 
7static int cmp(String s1, String s2) {
8    return s1.compareTo(s2);
9}

1Stream<BigInteger> naturals = createNaturalStream(); // 不计算
2Stream<BigInteger> s2 = naturals.map(BigInteger::multiply); // 不计算
3Stream<BigInteger> s3 = s2.limit(100); // 不计算
4s3.forEach(System.out::println); // 计算

1int result = createNaturalStream() // 创建Stream
2             .filter(n -> n % 2 == 0) // 任意个转换
3             .map(n -> n * n) // 任意个转换
4             .limit(100) // 任意个转换
5             .sum(); // 最终计算结果

1//字符串转化为日期，并打印
2SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
3List.of("2021-12-12","2021-12-13","2021-12-14")
4    .stream()
5    .map(n->sdf.parse(n))
6    .forEach(System.out::println);

 1private static void streamTest4() {
 2    List<String> list = new ArrayList<>();
 3    list.add("123,234");
 4    list.add("3456");
 5    list.add("456,789");
 6
 7    Set<String> strings = list.stream().map(e -> e.split(","))
 8        .flatMap(Arrays::stream)
 9        .collect(Collectors.toSet());
10    
11   // 输出：[123, 234, 3456, 456, 789]
12    System.out.println(strings);
13}

1// 过滤成绩小于15的Person
2Person p1=new Person("张三",12);
3Person p2=new Person("李四",21);
4Person p3=new Person("王五",35);
5List.of(p1,p2,p3).stream()
6    .filter(n->n.score>15)
7    .forEach(System.out::println);

 1int sum = 0;
 2for (n : stream) {
 3    sum = (sum, n) -> sum + n;
 4}
 5
 6// 将配置文件的每一行配置通过map()和reduce()操作聚合成一个Map<String, String>
 7List<String> props = List.of("profile=native", "debug=true", "logging=warn", "interval=500");
 8Map<String,String> map=props.stream()
 9    .map((kv)->{
10        String[] ss = kv.split("\\=", 2);
11        return Map.of(ss[0],ss[1]);
12    })
13    .reduce(new HashMap<>(),(o,v)->{
14        o.putAll(v);
15        return o;
16    });
17map.forEach((k,v)->{
18    System.out.println(k+":"+v);
19});
20
21//分组后根据某个属性分组，然后每组再次聚合，自定义收集器，返回Map
22Map<String,BigDecimal> res=list.stream().collect(
23    Collectors.groupingBy(Material::getType,
24                          Collectors.reducing(BigDecimal.ZERO, Material::getMoney, BigDecimal::add)));
25    
26    
27//对 bigdecimal 求和
28BigDecimal bigDecimal = decimalList.stream().filter(Objects::nonNull).reduce(BigDecimal.ZERO, (res,v)->{
29    return res.add(v);
30});

 1// list去重
 2//将集合放到TreeSet中，然后再将TreeSet转为List， 其中TreeSet要传入一个根据哪个属性进行比较的比较器，然后使用public ArrayList(Collection<? extends E> c)将TreeSet放入构造器中生成List
 3collect = personList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->
 4    new TreeSet<>(Comparator.comparing(e->e.name+e.score))
 5), ArrayList::new));
 6
 7//创建不变map
 8personList.stream().collect(Collectors.collectingAndThen(Collectors.toMap(e ->
 9     e.score+e.name, e -> e.score
10), HashMap::new));

 1/*
 2* T 入参类型
 3* A 容器类型
 4* R 结果类型
 5*/
 6public interface Collector<T, A, R> {
 7    /*
 8     * supplier参数用于生成结果容器，容器类型为A
 9     * 返回一个结果为空的 Supplier,也就是一个无参数函数,在调用时它会创建一个空的累加器实例，供数据收集过程使用
10    */ 
11    Supplier<A> supplier();
12    
13    /*
14     * accumulator用于消费元素，也就是归纳元素，这里的T就是元素，它会将流中的元素一个一个与结果容器A发生操作
15     * 返回执行归约操作的函数,当遍历到流中第n个元素时，
16     * 这个函数执行时会有两个参数：保存归约结果的累加器（已收集了流中的前 n-1 个项目），还有第n个元素本身
17     * 该函数将返回 void ，因为累加器是原位更新，即函数的执行改变了它的内部状态
18    */ 
19    BiConsumer<A, T> accumulator();
20    
21    /* 
22     * combiner用于两个两个合并并行执行的线程的执行结果，将其合并为一个最终结果A
23     * combiner 方法会返回一个供归约操作使用的函数，
24     * 它定义了对流的各个子部分进行并行处理时，各个子部分归约所得的累加器要如何合并
25    */
26    BinaryOperator<A> combiner();
27    
28    /* finisher用于将之前整合完的结果R转换成为A
29     * 在遍历完流后， finisher 方法必须返回在累积过程的最后要调用的一个函数，
30     * 以便将累加器对象转换为整个集合操作的最终结果
31    */
32    Function<A, R> finisher();
33    
34    /*
35     * NORDERED —— 归约结果不受流中项目的遍历和累积顺序的影响
36     * CONCURRENT —— accumulator 函数可以从多个线程同时调用，且该收集器可以并行归约流。如果收集器没有标为 UNORDERED ，那它仅在用于无序数据源时才可以并行归约
37     * IDENTITY_FINISH —— 这表明完成器方法返回的函数是一个恒等函数，可以跳过。这种情况下，累加器对象将会直接用作归约过程的最终结果。这也意味着，将累加器 A 不加检查地转换为结果 R 是安全的
38     */
39    Set<Characteristics> characteristics();
40}

 1//自定义collector实现，作用将BigDecimal求和，对于null忽略
 2Collector<BigDecimal,BigDecimal[],BigDecimal> collector=Collector.of(
 3    ()-> new BigDecimal[1],
 4    (a, t) -> {
 5        //这里对结果容器赋初始值
 6        if (a[0] == null) {
 7            a[0] = BigDecimal.ZERO;
 8        }
 9        //这里忽略流中null元素
10        if (t!=null){
11             a[0] = a[0].add(t);
12        }
13    },
14    (a, b) -> {
15        a[0] = a[0].add(b[0]);
16        return a;
17    },
18    a -> a[0],
19    Collector.Characteristics.IDENTITY_FINISH);
20
21list.stream().collect(collector);

 1// T 是流中要收集的项目的泛型
 2// A 是累加器的类型,累加器是在收集过程中用于累积部分结果的对象
 3// R 是收集操作得到的对象（通常但并不一定是集合）的类型
 4new Collector<BigDecimal, BigDecimal[], String>() {
 5    /**
 6     * 建立新的结果容器
 7     */
 8    @Override
 9    public Supplier<BigDecimal[]> supplier() {
10        return () -> new BigDecimal[1];
11    }
12
13    /**
14     * 将元素添加到结果容器
15     */
16    @Override
17    public BiConsumer<BigDecimal[], BigDecimal> accumulator() {
18        return (a,t)->{
19            if (a[0]==null){
20                a[0]=BigDecimal.ZERO;
21            }
22            if (t != null){
23                a[0]=a[0].add(t);
24            }
25        };
26    }
27
28    /**
29     * 合并两个结果容器
30     */
31    @Override
32    public BinaryOperator<BigDecimal[]> combiner() {
33        return (a1,a2)->{
34            a1[0]=a1[0].add(a2[0]);
35            return a1;
36        };
37    }
38
39    /**
40     * 对结果容器应用最终转换
41     */
42    @Override
43    public Function<BigDecimal[], String> finisher() {
44        return (a)-> a[0].toString();
45    }
46
47    /**
48     * 定义了收集器特性
49     */
50    @Override
51    public Set<Characteristics> characteristics() {
52        return Collections.unmodifiableSet(EnumSet.of(
53                Characteristics.CONCURRENT,
54                Collector.Characteristics.UNORDERED));
55    }
56}

 1List<BigDecimal> decimalList = Arrays.asList(
 2    new BigDecimal("1"),
 3    new BigDecimal("2"),
 4    new BigDecimal("3"),
 5    new BigDecimal("-10"),
 6    null,
 7    new BigDecimal("0")
 8);
 9
10//过滤null，并取最大值
11Optional<BigDecimal> max = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
12if (max.isPresent()) {
13    BigDecimal maxdecimal = max.get();
14}
15
16//过滤null，并取最小值
17Optional<BigDecimal> min = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
18if (max.isPresent()) {
19    BigDecimal mindecimal = max.get();
20}

 1List<BigDecimal> decimalList = List.of(
 2    new BigDecimal("1"),
 3    new BigDecimal("2"),
 4    new BigDecimal("3"),
 5    null,
 6    new BigDecimal("-10"),
 7    new BigDecimal("0")
 8);
 9
10//求decimalList所有元素乘积，并忽略null元素
11String res = decimalList.stream().collect(Collector.of(
12    () -> new BigDecimal[1],
13    (a, t) -> {
14        if (a[0] == null) {
15            a[0] = BigDecimal.ONE;
16        }
17        if (t != null && t.compareTo(BigDecimal.ZERO) != 0) {
18            a[0] = a[0].multiply(t);
19        }
20    },
21    (a1, a2) -> {
22        a1[0] = a1[0].multiply(a2[0]);
23        return a1;
24    },
25    (a) -> a[0].toString()
26));

 1List<String> arr=new ArrayList<>();
 2for (int i = 0; i < 10950; i++) {
 3    arr.add(String.valueOf(i));
 4}
 5
 6int step = 100;
 7
 8List<List<String>> lists = Stream.iterate(0L, n -> n + 1L)   //返回一个无限有序流 0123456.......
 9    .limit((arr.size() + step - 1) / step)   //指定最后返回的 list大小，
10    .parallel()  //转换并行流
11    .map(a -> arr.stream().skip(a * step)
12         .limit(step).parallel()   //转换为并行流并进行归约
13         .collect(Collectors.toList()))
14    .collect(Collectors.toList());