package stream;

import java.util.*;
import java.util.stream.*;

/**
 * @Description
 * @Author msli
 * @Date 2021/08/17
 */

public class StreamDemo {


    public static void main(String[] args) {
//        constructStreamDemo();
        streamOps();
//        ArrayList<Integer> nums = new ArrayList<>();
//        nums.add(1);
//        nums.add(12);
//        nums.add(48);
//        nums.add(7);
//        nums.add(25);
//        List<Integer> integers = nums.subList(0, 3);
//        Integer[] integers1 = integers.toArray(new Integer[0]);
//        System.out.println(Arrays.toString(integers1));

        /**
         * 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时，一定要使
         * 用含有参数类型为 BinaryOperator，参数名为 mergeFunction 的方法，否则当出现相同 key
         * 值时会抛出 IllegalStateException 异常
         */
//        List<Pair> pairs = new ArrayList<>();
//        pairs.add(new Pair("version", 12.10));
//        pairs.add(new Pair("version", 12.19));
//        pairs.add(new Pair("version", 6.28));
//        final Map<String, Double> collect = pairs.stream().collect(Collectors.toMap(Pair::getE1, Pair::getE2, (v1, v2) -> v2));
//        System.out.println("collect = " + collect.toString());
//        // 反例
//        String[] departments = new String[] {"iERP", "iERP", "EIBU"};
//        // 抛出 IllegalStateException 异常
////        Map<Integer, String> map = Arrays.stream(departments)
////                .collect(Collectors.toMap(String::hashCode, str -> str));
////        System.out.println("map = " + map.toString());
//        // 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时，一定要注
//        // 意当 value 为 null 时会抛 NPE 异常。
//        List<Pair> pairList = new ArrayList<>();
//        pairList.add(new Pair("version", 12.10));
//        pairList.add(new Pair("version", 12.19));
//        pairList.add(new Pair("version", null));
//        final Map<String, Double> map1 = pairList.stream().collect(Collectors.toMap(Pair::getE1, entry -> Optional.ofNullable(entry.getE2()).orElse(0D), (v1, v2) -> v2));
//        System.out.println("map1 = " + map1.toString());

    }

    static class Pair {

        private String e1;
        private Double e2;

        public Pair(String e1, Double e2) {
            this.e1 = e1;
            this.e2 = e2;
        }

        public String getE1() {
            return e1;
        }

        public void setE1(String e1) {
            this.e1 = e1;
        }

        public Double getE2() {
            return e2;
        }

        public void setE2(Double e2) {
            this.e2 = e2;
        }
    }

    /**
     * 流的操作
     * 分类：
     * 1. Intermediate 操作
     * map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
     * 一个流可以后面跟随零个或多个intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。
     * 这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历
     * 2. Terminal 操作
     * forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
     * 一个流只能有一个terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。
     * 所以,这必定是流的最后一个操作。Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个side effect
     * 3. Short-circuiting 操作
     * anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
     * 对于一个intermediate操作，如果它接受的是一个无限大（infinite/unbounded）的Stream，但返回一个有限的新Stream；
     * 对于一个terminal操作，如果它接受的是一个无限大的Stream，但能在有限的时间计算出结果。
     * 当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个short-circuiting操作是必要非充分条件
     */
    public static void streamOps() {

        /**
         * map/flatMap
         * intermediate 操作
         * 作用：把 inputStream 的每个元素映射成 outputStream 的另外一个元素
         * 特点：map 生成的是个1:1映射，每个输入元素都按照规则转换成为另外一个元素
         *      flatMap 是一对多映射关系
         */
        List<Integer> nums = Arrays.asList(1, 2, 3, 4);
        List<Integer> squareList = nums.stream().map(n -> n * n).collect(Collectors.toList());
        String squareListStr = squareList.stream().map(String::valueOf).collect(Collectors.joining(","));
        System.out.println(squareListStr);
        Stream<List<Integer>> stream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
        System.out.println(stream.map(String::valueOf).collect(Collectors.joining(",")));
        stream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
        List<Integer> flatMapList = stream.flatMap(Collection::stream).collect(Collectors.toList());
        System.out.println(flatMapList.stream().map(String::valueOf).collect(Collectors.joining(",")));

        /**
         * filter 过滤筛选
         * intermediate 操作
         * 作用：filter对原始Stream进行某项测试，通过测试的元素被留下来生成一个新Stream
         * 留下偶数
         */
        Integer[] sixNums = {1, 2, 3, 4, 5, 6};
        Integer[] evens = Stream.of(sixNums).filter(n -> n % 2 == 0).toArray(Integer[]::new);
        System.out.println(Arrays.toString(evens));


        /**
         * forEach
         * terminal 操作
         * 作用：forEach方法接收一个Lambda表达式，然后在Stream的每一个元素上执行该表达式
         * 多核系统优化时，可以parallelStream().forEach()，只是此时原有元素的次序没法保证，并行的情况下将改变串行时操作的行为，此时forEach本身的实现不需要调整
         * forEach是terminal操作, 执行后，Stream 的元素就被“消费”掉了，你无法对一个Stream进行两次terminal运算
         * forEach 不能修改自己包含的本地变量值，也不能用break/return之类的关键字提前结束循环。
         */
        Integer[] nums2 = {1, 2, 3, 4, 5, 6, 84};
        Stream.of(nums2).filter(n -> n > 3).forEach(System.out::println);

        /**
         * peek
         * intermediate 操作
         * 与 forEach 功能类型
         */
        List<String> list = Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3)
                .peek(e -> System.out.println("Filtered value: " + e)).map(String::toUpperCase)
                .peek(e -> System.out.println("Mapped value: " + e)).collect(Collectors.toList());

        /**
         * findFirst
         * termimal兼short-circuiting操作
         * 返回Stream的第一个元素或者空
         * 它的返回值类型Optional:这也是一个模仿 Scala 语言中的概念，作为一个容器，它可能含有某值，或者不包含,使用它的目的是尽可能避免NullPointerException
         * 类似的：findAny、max/min、reduce等方法等返回Optional值
         */
        Optional<String> firstStr = Stream.of("one", "two", "tt", "tt23").filter(element -> element.contains("tt")).findFirst();
        System.out.println("findFirstStr: " + firstStr.get());

        /**
         * reduce
         * termimal兼short-circuiting操作
         * 把Stream元素组合起来
         * 提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面Stream的第一个、第二个、第n个元素组合;
         * 从这个意义上说，字符串拼接、数值的 sum、min、max、average都是特殊的reduce
         */
        //  求和，sumValue = 1 + 1+2+3+4 = 11 , 有起始值
        // reduceStream.reduce(0, (a, b) -> a+b);
        int sumValue = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum);
        System.out.println("reduce 求和 有起始值 " + sumValue);
        // 求和，sumValue = 10, 无起始值
        sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
        System.out.println("reduce 求和 无起始值 " + sumValue);
        // 字符串连接，concat = "ABCD"
        String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
        System.out.println("reduce 字符串连接 " + concat);
        String concat1 = Stream.of("A", "B", "C", "D").reduce(";", String::concat);
        System.out.println("reduce 字符串连接 " + concat1);
        // 求最小值，minValue = -3.0
        double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
        System.out.println("reduce 求最小值 " + minValue);
        // 过滤，字符串连接，concat = "ace"
        concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);
        System.out.println("reduce 过滤+字符串连接 " + concat);

        /**
         * limit / skip
         * intermediate 操作
         * limit返回Stream的前面n个元素
         * skip则是扔掉前n个元素（它是由一个叫 subStream的方法改名而来）
         */
        int[] ints = IntStream.rangeClosed(1, 100).limit(20).skip(10).toArray();
        System.out.println(Arrays.toString(ints));
    }

    /**
     * 流转为其他数据结构 demo
     */
    public static void typeConvert() {
        Stream<String> stream = Stream.of("a", "c", "regfgfdfd");

        // 1. to array
        String[] array = stream.toArray(String[]::new);

        // 2. to collect
        List<String> list1 = stream.collect(Collectors.toList());
        ArrayList<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
        HashSet<String> sets = stream.collect(Collectors.toCollection(HashSet::new));
        Stack<String> stack = stream.collect(Collectors.toCollection(Stack::new));

        // 3. String
        String str = stream.collect(Collectors.joining(", ", "[", "]"));
    }

    /**
     * 不同方式的流构造类型
     */
    public static void constructStreamDemo() {
        // 1. 单个元素
        Stream stream = Stream.of("a", "b", "c");
        System.out.println("individualStream");
        stream.forEach(System.out::println);

        // 2. 数组
        String[] strArr = new String[]{"a", "b", "c"};
        Stream<String> stream1 = Stream.of(strArr);
        Stream<String> stream2 = Arrays.stream(strArr);
        // 基本数值类型数组 IntStream LongStream DoubleStream
        int[] ints = new int[]{1, 23, 32};
        IntStream intStream = IntStream.of(ints);
        intStream = Arrays.stream(ints);
        System.out.println("intStream");
        intStream.forEach(System.out::println);
        IntStream.rangeClosed(1, 444).forEach(item -> System.out.print(item + " "));
        System.out.println();

        double[] doubles = {3.4, 232, 90};
        DoubleStream doubleStream = DoubleStream.of(doubles);
        doubleStream = Arrays.stream(doubles);
        System.out.println("doubleStream");
        doubleStream.forEach(System.out::println);

        long[] longs = {2L, 4343434L, 232L};
        LongStream longStream = LongStream.of(longs);
        longStream = Arrays.stream(longs);
        System.out.println("longStream");
        longStream.forEach(System.out::println);

        // 3. 集合
        List<String> stringList = Arrays.asList(strArr);
        Stream<String> stream3 = stringList.stream();
        System.out.println("collectStream");
        stream3.forEach(System.out::println);
    }

}