Java8新特性代码示例（附注释）- 方法引用，Optional， Stream

  /**
     * java8中的函数式接口，java中规定：函数式接口必须只有一个抽象方法，可以有多个非抽象方法，同时，如果继承实现了
     * Object中的方法，那么也是合法的
     * <p>
     * 函数式接口可以使用lambda来创建
     */
    @FunctionalInterface
    interface MyService {
        void sayMessage(String msg);

        @Override
        boolean equals(Object obj);
    }

    /**
     * 入口
     * @param args
     */
    public static void main(String[] args) {
        printSeperator();
        testMehtodRef();
        printSeperator();

        testSupplierConsumer();
        printSeperator();

        testOptional();
        printSeperator();

        testStream();
        printSeperator();
    }

    /**
     * 测试Optional类
     */
    private static void testOptional() {
        Optional<String> optional1 = Optional.ofNullable(null);
        //如果optional确实存在值，那么该函数返回值为true
        if (optional1.isPresent()) {
            System.out.println("optional1 present!");
        }

        //如果optional没有值，那么默认返回传入的other
        String res = optional1.orElse("default");
        System.out.println("res's value after orElse:" + res);
        try {
            /**
             * 如果没有该值，那么抛出{@link NoSuchElementException}
             */
            res = optional1.orElseThrow();
            System.out.println("res's value after orElseThrow:" + res);
        } catch (NoSuchElementException e) {
            System.out.println("orElseThrow occured!");
        }

        optional1 = Optional.ofNullable("i have a value");
        res = optional1.orElse("default");
        System.out.println("res's value after orElse:" + res);
    }

    /**
     * 测试{@link java.util.function.Supplier} and {@link java.util.function.Consumer}
     */
    private static void testSupplierConsumer() {
        Supplier<String> supplier1 = new Supplier<String>() {
            @Override
            public String get() {
                return new String("hello world from supplier1");
            }
        };

        //lambda式的supplier，supplier的规定是无参数，且返回一个对象，因此满足该条件
        Supplier<String> supplier2 = () -> new String("hello world from supplier2");

        //本质上supplier是一个容器，对一个方法的封装
        var str1 = getSupplier(supplier1);
        var str2 = getSupplier(supplier2);
        //方法引用默认返回一个supplier，因为该new不接受任何参数，返回一个对象，因此满足条件
        var str3 = getSupplier(String::new);
        System.out.println("str1: " + str1 + "   str2:" + str2 + "   str3:" + str3);

        /////////////////////////////////////////////////////////////////////////////////////////////
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s + "|");
            }
        };
        //lambda式的Consumer，Consumer的约定是接受一个参数，返回值为void，因此满足条件
        Consumer<String> consumer2 = (s) -> System.out.print(s + "^");
        var list = getStrList();
        list.forEach(consumer1);
        System.out.println();
        list.forEach(consumer2);
        System.out.println();

        /////////////////////////////////////////////////////////////////////////////////////////////
        //Predicate谓词接口，用于判断是否符合某个条件，约定是：接受一个参数，返回值为boolean
        Predicate<Integer> predicate1 = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 2;
            }
        };

        //lambda式的谓词接口
        Predicate<Integer> predicate2 = (num) -> num > 2;
        var numList = getIntList();
        var res = numList.stream().filter(predicate1).collect(Collectors.toList());
        System.out.println(res);
        res = numList.stream().filter(predicate2).collect(Collectors.toList());
        System.out.println(res);

        /////////////////////////////////////////////////////////////////////////////////////////////
        //Function接口：这是一个功能性的接口，主要用于把一种类型的数据处理完成后，可能得到的结果是另外一种类型
        //本质上是上面那些接口的超集，第一个参数为接口的类型，第二个参数为转换后的类型
        Function<String, Character> func1 = new Function<String, Character>() {
            @Override
            public Character apply(String s) {
                if (s.length() <= 2) {
                    return 'a';
                }
                return s.charAt(2);
            }
        };

        Function<String, Character> func2 = (s) -> {
            return s.length() <= 2 ? 'a' : s.charAt(2);
        };
        var varList = getStrList();
        var res2 = varList.stream().map(func1).collect(Collectors.toList());
        System.out.println(res2);
        res2 = varList.stream().map(func2).collect(Collectors.toList());
        System.out.println(res2);
    }

    /**
     * 测试{@link java.util.stream.Stream}里面的函数接口，
     * Stream里面的函数接口非常的多，类似于SQL，分为两种：
     * 1 中间函数 immediate function
     * 2 最终函数（规约） terminal function
     */
    private static void testStream() {
        //将一个数字list，先过滤到大于3的数，然后转换为对应的字母，最后在大写，最后重新收集为一个List
        List<Integer> numList = getIntList();
        List<String> res = numList.stream().filter((num) -> num > 3).map(num -> String.valueOf((char)('a' + num)))
                .map(str -> String.valueOf((char)('A' + str.charAt(0) - 'a'))).collect(Collectors.toList());
        System.out.println(res);

        final int size = 100;
        int[] arr = new int[size];
        Random random = new Random();
        for(int i = 0;i < size;++i){
            arr[i] = random.nextInt(1000);
        }
        //对numArr进行排序，然后得到最前面的5个数据，最后得到最大值
        var res2 = Arrays.stream(arr).sorted().limit(5).min();
        System.out.println("res2:"+ res2.orElseThrow());
    }

    /**
     * 辅助类
     *
     * @param supplier
     * @param <T>
     * @return
     */
    private static <T> T getSupplier(Supplier<T> supplier) {
        return supplier.get();
    }

    /**
     * 测试方法引用的用法
     */
    private static void testMehtodRef() {
        List<String> strs = new ArrayList<>();
        strs.add("one");
        strs.add("two");
        strs.add("three");
        strs.add("four");

        //printSomething本质上是一个Consumer
        strs.forEach(HelloJava8::printSomething);
        System.out.println();
    }

    /**
     * 打印一些东西
     *
     * @param s
     */
    private static void printSomething(String s) {
        System.out.print(s + "\t");
    }

    private static void printSeperator() {
        System.out.println(SEPERATOR);
    }

    /**
     * 辅助方法，获辅助list
     *
     * @return
     */
    private static List<String> getStrList() {
        List<String> strs = new ArrayList<>();
        strs.add("one");
        strs.add("two");
        strs.add("three");
        strs.add("four");
        return strs;
    }

    /**
     * 获取辅助list
     *
     * @return
     */
    private static List<Integer> getIntList() {
        List<Integer> intList = new ArrayList<>();
        for (int i = 1; i <= 10; ++i) {
            intList.add(i);
        }
        return intList;
    }