Java8-1-新特性_Lambda表达式

package cn.jdk.MethodReference;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

import javax.annotation.processing.SupportedOptions;

import cn.jdk.lambda.Apple;

/**
 * 
 * JDK8新特性 方法引用
 * 
 * @author 梦见猫、 2018年4月17日
 */
public class MethodReferenceTest {

    public static void main(String[] args) {

        // 1. 第一种方式, 像创建类型一样创建consumer;
        Consumer<String> con = s -> System.out.println(s);
        useConsumer(con, "hello world");

        // 2. 第二种方式, 直接将右边的lambda表达式视为一个对象;
        useConsumer(s -> System.out.println(s), "hello world");

        // 3. 第三种方式, 对象引用System.out里面的方法给lambda表达式调用
        // 为什么可以这样呢? 因为sysout里面的println方法符合consumer的格式, 可以使用consumer格式的表达式进行方法引用
        useConsumer(System.out::println, "Hello world");

        // 下面来看看其他几种类型的表达式如何进行引用
        // 1.1 function 普通的function只能引用静态方法
        // Function<Integer, String> funcMethodReference = String::charAt; -- Cannot
        // make a static reference to the non-static method charAt(int) from the type
        // String;
        Function<String, Integer> funcMethodReference = Integer::parseInt;
        System.out.println(funcMethodReference.apply("12345"));

        // 1.2 BiFunction 加强版function; --> 对象没有实例的时候成员方法的引用
        // T=对象本身的类型 U=参数 R=返回类型
        BiFunction<String, String, Integer> biFunctionMethodReference = String::indexOf;
        // 但是呢, 这种类型的不能这样创建--The method parseInt(String) from the type Integer should be
        // accessed in a static way
        // BiFunction<Integer, String, Integer> biFunctionMethodReference2 =
        // Integer::parseInt;
        System.out.println(biFunctionMethodReference.apply("hello world", "h"));

        // 1.3 对象有实例的时候成员方法的引用;
        // T=参数类型, R=返回值类型;
        String str = "hello world";
        Function<String, Integer> funcMethodReference2 = str::indexOf;
        System.out.println(funcMethodReference2.apply("e"));

        // Supply方法省略;-->有实例entity的get方法;

        // 2. 初始化方法的引用;
        Supplier<String> supplier = String::new;
        String s = supplier.get();
        System.out.println(s);
        
        // 2.1 构造函数参数为1;
        Function<String, Apple> appleFuntion = Apple::new;
        Apple apple = appleFuntion.apply("red");
        System.out.println(apple);

        // 2.2 构造函数参数为2;
        BiFunction<String, Long, Apple> appleFuntion1 = Apple::new;
        Apple apple2 = appleFuntion1.apply("red", 100L);
        System.out.println(apple2);

        // 2.3 如果构造函数大于2怎么办呢? 使用自定义的Function类型进行构造;
        ThreeFunction<String, Long, String, ComplexApple> threeFunction = ComplexApple::new;
        ComplexApple complexApple = threeFunction.apply("Green", 123L, "FuShi");
        System.out.println(complexApple);
        
        //--------------------------------------------------
        // 为什么说表达式可以简化代码呢? 下面我们来看一个例子
        // List的Compare
        List<Apple> list1 = Arrays.asList(new Apple("abc", 123), new Apple("Green", 110), new Apple("red", 124));
        // 1. 最原始的方法;
        Collections.sort(list1, new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return (int) (o1.getWeight() - o2.getWeight());
            }
        });
        System.out.println(list1);
        
        // 2. lambda表达式
        List<Apple> list2 = Arrays.asList(new Apple("abc", 123), new Apple("Green", 110), new Apple("red", 124));
        list2.sort((o1, o2)-> (int)o1.getWeight() - (int)o2.getWeight());
        System.out.println(list2);
        
        // 3. 最强简写;
        List<Apple> list3 = Arrays.asList(new Apple("a", 123), new Apple("b", 110), new Apple("red", 124));
        // 可以理解为Apple::getColor就是一个function, 方法引用的几种类型都是返回function

　　　　 list3.sort(Comparator.comparing(Apple::getColor));

        System.out.println(list3);
        
        Function<Long, Long> funcLong = x -> x+1;
    }

    /**
     * 这个方法传入一个consumer类型的lambda表达式, 可以有三种方法进行优化
     * @param consumer
     * @param t
     */
    private static <T> void useConsumer(Consumer<T> consumer, T t) {
        consumer.accept(t);
    }

}

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }