stream流的基本操作

package com.zs.lamda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.junit.Test;

/**
 * @author zhaoshuai06 <zhaoshuai06@kuaishou.com>
 * Created on 2021-06-09
 */
public class TestLamda {
    private static ArrayList<Apple> arrayList = new ArrayList<>();
    private static ArrayList<String> stringArrayList = new ArrayList<>();
    static {
        arrayList.add(new Apple(1, "red", 500, "湖南"));
        arrayList.add(new Apple(1, "red", 500, "湖南"));
        arrayList.add(new Apple(2, "red", 400, "湖南"));
        arrayList.add(new Apple(3, "green", 300, "湖南"));
        arrayList.add(new Apple(4, "green", 200, "天津"));
        arrayList.add(new Apple(5, "green", 100, "天津"));
    }

    static {
        stringArrayList.add("aaa bbb ccc");
        stringArrayList.add("ddd eee fff");
        stringArrayList.add("ggg hhh iii");
    }

    @Test
    //filter: 是一种过滤的方法 == 相当于 if()
    public void test_filter() {
        List<Apple> redList = arrayList.stream()
                .filter(item -> item.getColor().equals("red"))
                .collect(Collectors.toList());
        System.out.println(redList);
    }

    @Test
    //distinct: 去除重复元素
    public void test_distinct() {
        List<Apple> redList = arrayList.stream()
                .filter(item -> item.getColor().equals("red"))
                .distinct()
                .collect(Collectors.toList());
        System.out.println(redList);
    }

    @Test
    //sorted: 按id逆序排列输出
    public void test_sorted() {
        List<Apple> redList = arrayList.stream()
                .distinct()
                .sorted((p1, p2) -> p2.getId() - p1.getId())
                .collect(Collectors.toList());
        System.out.println(redList);
    }

    @Test
    //limit(2): 返回前两个元素
    public void test_limit() {
        List<Apple> redList = arrayList.stream()
                .distinct()
                .sorted((p1, p2) -> p2.getId() - p1.getId())
                .limit(2)
                .collect(Collectors.toList());
        System.out.println(redList);
    }

    @Test
    //skip(2): 跳过前两个元素
    public void test_skip() {
        List<Apple> redList = arrayList.stream()
                .distinct()
                .sorted((p1, p2) -> p2.getId() - p1.getId())
                .skip(2)
                .collect(Collectors.toList());
        System.out.println(redList);
    }

    // map(Apple::getOrigin) == .map(item -> item.getOrigin())： 将流中的每一个元素 T 映射为 R（类似类型转换）
    @Test
    public void testMap() {
        List<String> newList = arrayList.stream()
                .map(Apple::getOrigin) //.map(item -> item.getOrigin())
                .collect(Collectors.toList());
        System.out.println(newList);
    }

    @Test
    // 我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List
    // flatMap(Arrays::stream)
    //首先 map 方法分割每个字符串元素，但此时流的类型为 Stream<String[ ]>，因为 split 方法返回的是 String[ ] 类型；
    // 所以我们需要使用 flatMap 方法，先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream 流，
    // 然后 flatMap 会将每一个流连接成为一个流，最终返回我们需要的 Stream;
    public void testFlatMap() {
        List<String> result = stringArrayList.stream()
                .map(item -> item.split(" "))
                .flatMap(Arrays::stream)
                .collect(Collectors.toList());
        System.out.println(result);
    }

    @Test
    //anyMatch(T -> boolean) ：流中是否有一个元素匹配给定的 T -> boolean 条件
    public void testAnyMatch() {
        boolean result = arrayList.stream()
                .anyMatch(item -> item.getOrigin().equals("天津"));
        System.out.println(result);
    }

    @Test
    // allMatch(T -> boolean)：流中是否所有元素都匹配给定的 T -> boolean 条件
    public void testAllMatch() {
        boolean result = arrayList.stream()
                .allMatch(item -> item.getOrigin().equals("天津"));
        System.out.println(result);
    }

    @Test
    // noneMatch(T -> boolean)：流中是否没有元素匹配给定的 T -> boolean 条件
    public void testNoneMatch() {
        boolean result = arrayList.stream()
                .noneMatch(item -> item.getOrigin().equals("北京"));
        System.out.println(result);
    }

    @Test
    public void testFindAnyOrAll() {
        Optional<Apple> any = arrayList.stream()
                .findAny();
        System.out.println(any.get());
        Optional<Apple> first = arrayList.stream()
                .findFirst();
        System.out.println(first.get());
    }

    @Test
    // reduce(0, Integer::sum):
    //reduce 第一个参数 0 代表起始值为 0, 将两值相加产生一个新值
    public void testReduce() {
        Integer result = arrayList.stream()
                .map(Apple::getWeight)
                .reduce(0, Integer::sum);
        System.out.println(result);

        Optional<Integer> result_multi = arrayList.stream()
                .map(Apple::getId)
                .distinct()
                .reduce((a, b) -> a * b); //1 2 3 4 5
        System.out.println(result_multi.get());
    }
    @Test
    public void test() {
        long result_count = arrayList.stream()
                .distinct()
                .count();
        System.out.println(result_count);
    }

    @Test
    public void testCollect() {
        List<Apple> res_collect = arrayList.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("res_collect = " + res_collect);

        Map<Integer, Apple> res_map = arrayList.stream()
                .distinct()
                .collect(Collectors.toMap(Apple::getId, Function.identity())); //1=Apple(id=1, color=red, weight=500, origin=湖南)
        System.out.println(res_map);
    }

    @Test
    public void testForEach() {
        List<Integer> int_list = new ArrayList<>();
        arrayList.stream()
                .distinct()
                .forEach(item -> int_list.add(item.getId()));
        System.out.println(int_list);
    }

    @Test
    public void testGroup() {
        Map<String, List<Apple>> res_map = arrayList.stream()
                .distinct()
                .collect(Collectors.groupingBy(Apple::getOrigin));
        System.out.println(res_map);

        Map<String, Double> res_map = arrayList.stream()
                .collect(Collectors.groupingBy(Apple::getOrigin, Collectors.averagingInt(Apple::getId)));
        System.out.println(res_map);

        Map<String, Integer> res_map = arrayList.stream()
                .distinct()
                .collect(Collectors.groupingBy(Apple::getOrigin, Collectors.summingInt(Apple::getWeight)));
        System.out.println(res_map);
    }

    @Test
    public void testPartitioningBy() {
        Map<Boolean, List<Apple>> res_map = arrayList.stream()
                .collect(Collectors.partitioningBy(item -> item.getColor().equals("red")));
        System.out.println(res_map);
    }







    @Test
    // find red apple and weight > 400
    public void findRedAndWeightApple() {
        List<Apple> redList = arrayList.stream()
                .filter(item -> item.getColor().equals("red") && item.getWeight() > 400)
                .collect(Collectors.toList());
         System.out.println(redList);
    }

    @Test
    // find red apple and groupByRed
    public void findRedAndWeightApple1() {
        arrayList.stream()
                .filter(item -> item.getColor().equals("red"))
                .collect(Collectors.groupingBy(
                        item -> item.getColor(),
                        Collectors.averagingInt(item -> item.getWeight())
                        )
                )
                .forEach((k, v) -> System.out.println(k + ":" + v));

    }
}

 @Test
    public void test_inner_class() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();
    }

改变成lamda的形式：

    @Test
    public void test_inner_class() {
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
    }

---

    @Test
    public void test_inner_class_1() {
        List<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        Collections.sort(integers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(integers);
    }

  @Test
    public void test_inner_class_1() {
        List<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        Collections.sort(integers, (o1, o2) -> o2 - o1);
        System.out.println(integers);
    }

省去了new 接口名；简化为() ->{…} 实际也是实现且创建一个接口对象。
一个方法的参数，括号中是否可以使用Lambda表达式，取决于这个方法的参数类型：
----是否是一个函数式接口（只有一个抽象方法可以有多个default方法的接口），构造方法也同理。
抽象方法中Object类下的方法除外。