Java8 4大函数式接口

    翻开optional 类，发现都是函数式接口，所以函数式接口Function你必须了解；

代码

    @Test
    public void test2() {
    
/*  @FunctionalInterface
    public interface Function<T, R> {

        // 输入T,返回 R ，这里T和R 谁是输入谁是输出，这样理解记忆只有先输入才有输出，

        //所以第一是输入类型，第二个是输出类型
        R apply(T t);

        //compose 组合，源码 before先执行apply，然后将得到的值，代入当前表达式
        default <V> java.util.function.Function<V, R> compose(java.util.function.Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }


        //andThen 跟javaScirpt命名一样，先执行当前表达式，然后将得到的值代入第二个表达式
        default <V> java.util.function.Function<T, V> andThen(java.util.function.Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }

        //其实就是将本身返回
        static <T> java.util.function.Function<T, T> identity() {
            return t -> t;
        }
    }
 */



        System.out.println("-------------Function-------------");
        Function<Integer,Integer> count=i->i+2;
        Function<Integer,Integer> count2=i->i*2;
        System.out.println(count.apply(5)); //7

        //count2.compose(count) 等同于 count3
        Function<Integer,Integer> count3=i->(i+2)*2;
        System.out.println(count2.compose(count).apply(5)); // (5+2)*2 =14

        List<String> languages = Arrays.asList("C++", "java", "python");
        Map<String, Integer> map = languages.stream().collect(Collectors.toMap(key -> key, String::length));
        System.out.println(map); //{python=6, C++=3, java=4}
        Map<String, Integer> map2 = languages.stream().collect(Collectors.toMap(Function.identity(), String::length));
        System.out.println(map2);{python=6, C++=3, java=4}


/*      @FunctionalInterface
        public interface Predicate<T> {

            //将t 代入lamda布尔表达式，返回一个boolean值
            boolean test(T t);

            //输入一个Predicate，返回一个Predicate，并且有短路功能，当前先执行，然后other再执行
            default java.util.function.Predicate<T> and(java.util.function.Predicate<? super T> other) {
                Objects.requireNonNull(other);
                return (t) -> test(t) && other.test(t);
            }

            //取非
            default java.util.function.Predicate<T> negate() {
                return (t) -> !test(t);
            }

            //逻辑或
            default java.util.function.Predicate<T> or(java.util.function.Predicate<? super T> other) {
                Objects.requireNonNull(other);
                return (t) -> test(t) || other.test(t);
            }
            
            static <T> java.util.function.Predicate<T> isEqual(Object targetRef) {
                return (null == targetRef)
                        ? Objects::isNull
                        : object -> targetRef.equals(object);
            }
        }*/

        //
        System.out.println("--------------Pridicate------------");
        Predicate<String> p1=x->x.equals("123");
        System.out.println(p1.test("123"));
        Predicate<String> p2=x->x.contains("12");
        System.out.println(p1.and(p2).test("1234"));
        System.out.println(p1.or(p2).test("1234"));
        System.out.println(p1.negate().test("1234"));



/*      @FunctionalInterface
        public interface Consumer<T> {
        //消费者，顾名思义，接收一个参数做业务操作，不产生返回值
            void accept(T t);
        
        //顺序执行 lamda表达式，先执行当前表达式，再执行after表达式
            default java.util.function.Consumer<T> andThen(java.util.function.Consumer<? super T> after) {
                Objects.requireNonNull(after);
                return (T t) -> { accept(t); after.accept(t); };
            }
        }*/

        System.out.println("------------Consumer--------------");
        Consumer<String> consumer1=x-> System.out.println(x+"dsjklfjklsad");
        Consumer<String> consumer2=x-> System.out.println(x.toUpperCase());
        consumer1.accept("1232"); //1232dsjklfjklsad
        consumer2.accept("abc");  //ABC
        consumer2.andThen(consumer1).accept("999abc"); //
        //结果
        //1232dsjklfjklsad
        //ABC
        //999ABC
        //999abcdsjklfjklsad

/*      @FunctionalInterface
        public interface Supplier<T> {
            //生产者，不接受参数，生厂一个对象
            T get();
        }*/
        System.out.println("------------Supplier--------------");
        Supplier<String> supplier=()->"123";
        System.out.println(supplier.get()); //123


    }