java 8 方法引用使用介绍

/***
 *
 * java 中 lambda 表达式的类型 是函数接口类型 ： FunctionalInterface
 * 接口的  抽象方法 的参数 和返回值就是 Lambda 表达式的 参数和 返回类型
 *
 *   -> 分割函数的参数和 函数体。 单行的函数体可以省略大括号
 *   由于类型可以推断，可以省略参数类型
 *
 * 情况一 ： 参数为空 ，括号不可以省略。 例如Runnable 接口
 * 情况二 ： 单个参数 。可以省略括号 。OnClickListener
 * 情况三 ： 多个参数 ，保留括号和参数名。 Comparator
 *
 *
 *  方法引用：当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些 。
 *  以interface Consumer<T>  void accept(T t);   这个 函数接口为例  。 返回值为空，只接受一个参数
 *  以下以Car 类 为例 ，Lambda 表达式 分别调用了
 *  Car.collide(cc) 静态方法 ，参数 为 Car 对象 。     方法引用  Car::collide
 *  cc.repair()的 非静态方法 。 执行对象为 Car 对象。无参数 。   方法引用  Car::repair
 *  police.follow(cc) 的非静态方法。 这个方法比较特殊 ，执行对象和 参数类型都是 Car 类型 。   由于使用到了别的Car 对象，所以 简化为 police::follow
 *
 *
 *
 */
public class JavaLambdaTest {
    public  static void main(String args[]){
        Runnable runnable = ()->System.out.println("  java 的 lambada 语句是一个 函数接口的对象 ");

        View.OnClickListener onClickListener = view-> System.out.println(" hahahaha");

        String[] arr = {"kotlin", "fuck", "java"};
        Arrays.sort(arr, (String m, String n) -> Integer.compare(m.length(), n.length()));
        Comparator<String> comparator =  ( m,  n) -> Integer.compare(m.length(), n.length());




        //构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：

        final Car car = Car.create( Car::new );
        final List< Car > cars = Arrays.asList( car );


        // 静态方法引用：它的语法是Class::static_method，实例如下：
        Consumer<? super Car> consumer1 =  Car::collide;
        Consumer<? super Car> consumer11 =  cc-> Car.collide(cc);
        cars.forEach( Car::collide );

        //特定类的任意对象的方法引用：它的语法是Class::method实例如下：
        Consumer<? super Car> consumer2 =  Car::repair ;
        Consumer<? super Car> consumer22 = cc-> cc.repair();
        cars.forEach( Car::repair );

       // 特定对象的方法引用：它的语法是instance::method实例如下：

        final Car police = Car.create( Car::new );
        cars.forEach( police::follow );

        Consumer<? super Car> consumer3 =  police::follow;
        Consumer<? super Car> consumer33 =  cc->police.follow(cc);


    }


    @FunctionalInterface
    interface Supplier<T> {
        T get();
    }

    public static class Car {
        //Supplier是jdk1.8的接口，这里和lamda一起使用了
        public static Car create(final Supplier<Car> supplier) {
            return supplier.get();
        }

        public static void collide(final Car car) {
            System.out.println("Collided " + car.toString());
        }

        public void follow(final Car another) {
            System.out.println("Following the " + another.toString());
        }

        public void followByName(String carName) {
            System.out.println("Following the " + carName);
        }

        public void repair() {
            System.out.println("Repaired " + this.toString());
        }


    }


}