package basic;

import org.junit.Before;
import org.junit.Test;

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

/**
 * @author 海棠無香
 * @since 2022/10/30 7:01 下午
 */
public class StreamTest {
    public final static String MIDDLE_OPERATE = "中間操作";
    public final static String END_OPERATE = "終值操作";

    public static class CustomStream {
        public String operateName;
        public Integer id;
        public String describe;
        public String type;

        public CustomStream(String operateName, Integer id, String describe, String type) {
            this.operateName = operateName;
            this.id = id;
            this.describe = describe;
            this.type = type;
        }


        @Override
        public String toString() {
            return "Stream{" +
                    "operateName='" + operateName + '\'' +
                    ", id=" + id +
                    ", describe='" + describe + '\'' +
                    ", type='" + type + '\'' +
                    '}' + "\n";
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            CustomStream stream = (CustomStream) o;
            return Objects.equals(operateName, stream.operateName) && Objects.equals(id, stream.id) && Objects.equals(describe, stream.describe) && Objects.equals(type, stream.type);
        }

        @Override
        public int hashCode() {
            return Objects.hash(operateName, id, describe, type);
        }
    }

    private List<CustomStream> streams;

    public static void main(String[] args) {
        System.out.println("Stream  Test");
    }

    @Before
    public void beforeTest() {
        this.streams = new ArrayList<>();
        this.streams.add(new CustomStream("filter", 1, "過濾", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("distinct", 2, "去重-根據(jù)hashCode和equals方法對比", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("limit", 3, "數(shù)據(jù)量", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("skip", 4, "去掉前幾個", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("map", 5, "類型修改", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("peak", 6, "遍歷數(shù)據(jù)悼嫉，修改數(shù)據(jù)等", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("flatMap", 7, "將每個流的內(nèi)容拼接起來，進(jìn)行扁平化操作", StreamTest.MIDDLE_OPERATE));
        this.streams.add(new CustomStream("collect", 11, "收集：轉(zhuǎn)為其他格式", StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("anyMatch", 12, "任意一個元素滿足條件",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("allMatch", 13, "任意全部元素都滿足條件",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("noneMatch", 14, "任意一個元素都不滿足條件",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("findAny", 15, "返回流中任意一個元素：Optional對象",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("findFirst", 16, "返回流中第一個元素",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("forEach", 17, "循環(huán)操作",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("count", 18, "數(shù)量",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("reduce", 19, "將結(jié)果依次整合",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("min", 20, "最大",  StreamTest.END_OPERATE));
        this.streams.add(new CustomStream("max", 21, "最小",  StreamTest.END_OPERATE));

        System.out.println(Objects.equals(this.streams.get(0), this.streams.get(2)));
    }

    /**
     * stream 是流式操作
     */
    @Test
    public void testStream() {
        List<CustomStream> collect = this.streams.stream()
                .filter(i -> i.id > 1)
                .distinct()
                .skip(2)
                .limit(4)
                .map(i -> {
                    System.out.println("map---");
                    // 類型轉(zhuǎn)換 -- 正常應(yīng)該使用 peak陋率，此處只演示用
                    i.id = i.id * 10;
                    return i;
                })
                .sorted((a, b) -> b.id - a.id) // 倒序
                .peek(i -> System.out.println("peak--"))
                .collect(Collectors.toList());

        System.out.println(collect);
        System.out.println("-----------------");
        System.out.println(this.streams);
    }

    /**
     * 測試 flatMap
     */
    @Test
    public void testFlatMap() {
        List<CustomStream> s1 = new ArrayList<>();
        s1.add(this.streams.get(0));
        s1.add(this.streams.get(1));
        s1.add(this.streams.get(2));

        List<CustomStream> s2 = new ArrayList<>();
        s2.add(this.streams.get(2));
        s2.add(this.streams.get(3));
        s2.add(this.streams.get(4));

        List<List<CustomStream>> lists = new ArrayList<>();

        lists.add(s1);
        lists.add(s2);
        List<CustomStream> collect = lists.stream().flatMap(Collection::stream).filter(i -> i.id > 2).collect(Collectors.toList());
        System.out.println(collect);
    }

    @Test
    public void testEnd() {
        boolean b = this.streams.stream().peek(System.out::println).anyMatch(i -> i.id > 3);
        System.out.println(b);

        Map<Integer, List<CustomStream>> collect = this.streams.stream().collect(Collectors.groupingBy(i -> i.id));
        System.out.println(collect);

        Integer reduce = this.streams.stream().map(i -> i.id).reduce(0, Integer::sum);

        System.out.println(reduce);
    }

    @Test
    public void testGroup() {
        // 分組統(tǒng)計類型數(shù)量
        Map<String, Integer> collect = this.streams.stream().collect(Collectors.toMap(i -> i.type, v -> 1, (o, n) -> o + 1));
        // Collectors.toMap 4個參數(shù)依次是：key田绑、value拉讯、key 重復(fù)時的value設(shè)置操作竭望、map類型
        TreeMap<String, Integer> collect5 = this.streams.stream().collect(Collectors.toMap(i -> i.type, v -> 1, (o, n) -> o + 1, TreeMap::new));

        // 獲取type值重復(fù)出現(xiàn)次數(shù)在1次之上的內(nèi)容
        List<String> collect4 = this.streams.stream().collect(Collectors.toMap(i -> i.type, v -> 1, (o, n) -> o + 1))
                .entrySet()
                .stream()
                .filter(i -> i.getValue() > 1)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
        System.out.println(collect4);

        // 按類型進(jìn)行分組： 一個參數(shù)：分組的key
        Map<String, List<CustomStream>> collect1 = this.streams.stream().collect(Collectors.groupingBy(i -> i.type));

        // 分組后底瓣，進(jìn)行統(tǒng)計：求和浅辙、平均值或者再分組等操作：兩個參數(shù)：第一個參數(shù)是分組的key扭弧，第二個參數(shù)是分組后的數(shù)據(jù)收集方式
        Map<String, Integer> collect2 = this.streams.stream().collect(Collectors.groupingBy(i -> i.type, Collectors.summingInt(i -> i.id)));

        // 指定map類型，默認(rèn)是hashMap：三個參數(shù)：第一個參數(shù)是分組的key记舆，第二個參數(shù)是map的類型鸽捻，第三個參數(shù)是分組后的數(shù)據(jù)收集方式
        TreeMap<String, Integer> collect3 = this.streams.stream().collect(Collectors.groupingBy(i -> i.type, TreeMap::new, Collectors.summingInt(i -> i.id)));

        System.out.println(collect3);
    }
}