//起步
    public static void main(String[] args) {
        //1. 接口实现类对象
        MyComparetor myComparetor = new MyComparetor();
        //2.使用匿名内部类
        Comparator comparator = new Comparator() {
            @Override
            public int compare(int a, int b) {
                return a - b;
            }
        };
        // 3. 使用lambda
        Comparator comparator1 = (a, b) -> a - b;
    }
}

class MyComparetor implements Comparator {
    @Override
    public int compare(int a, int b) {
        return a - b;
    }
}

  /*
    语法精简
   1. 参数类型可以省略 -》都要省略
   2. 参数小括号 参数列表中 如果只有一个参数 可以省去 小括号
   3. {} 如果只有一行代码就可以省略掉
   4. 如果代码块中只有一行代码  并且函数有返回  那么在省略 {} 的同时  必须省略 return 语句；
   */
    public static void main(String[] args) {
        LambdaNoReturnMutipleParamters lambdaNoReturnMutipleParamters = (a, b, c) -> {
            System.out.println("LambdaNoReturnMutipleParamters " + (a + b + c));
        };
        lambdaNoReturnMutipleParamters.test(12, 3, 4);

        LambdaMutipleReMutipleParamters lambdaMutipleReMutipleParamters = (a, b) -> a + b;
        System.out.println(lambdaMutipleReMutipleParamters.test(1, 2));
    }

    /*
   方法引用
   可以将一个Lambda表达式的实现指向一个已经实现的方法
   语法：方法的隶属者   ::
   注意：参数数量 类型 一致 ；返回值的类型需要一致
  */
    public static void main(String[] args) {

        LambdaSingleReSingleParamter lambdaSingleReSingleParamter = a -> a * 2;

        LambdaSingleReSingleParamter lambdaSingleReSingleParamter1 = a -> change(a);

        LambdaSingleReSingleParamter lambdaSingleReSingleParamter2 = Syntax3::change;//静态方法 ->  类::方法

        System.out.println(lambdaSingleReSingleParamter2.test(2));

    }

    public static int change(int a) {
        return a * 2;
    }


    public static void treeSet(String[] args) {
        //使用lambda 实现compar接口 并实例化一个对象
        TreeSet<Person> set = new TreeSet<Person>(((o1, o2) -> {
            if (o1.getAge() >= o2.getAge()) {
                return -1;
            } else {
                return 1;
            }
        }
        ));

        set.add(new Person("小明", 18, 96));
        set.add(new Person("小兰", 23, 98));
        set.add(new Person("小红", 21, 65));
        set.add(new Person("小崩", 20, 91));
        set.add(new Person("小绿", 19, 88));
        set.add(new Person("小d", 16, 68));
        set.add(new Person("小g", 14, 87));

        set.add(new Person("小r", 15, 83));
        set.add(new Person("小r", 15, 83));

        System.out.println(set);
    }

    //开辟线程
    public static void threads(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好");
            }
        });
        thread.start();

        Thread thread1 = new Thread(() -> {
            System.out.println("还行");
        });
        thread1.start();

        Callable callable = new Callable() {
            @Override
            public Object call() {
                return "放放风";
            }
        };
        try {
            Object o = callable.call();
            System.out.println(o.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }

        Runnable runnable = () -> System.out.println("run1");
        runnable.run();
        Object object = runnable;
        //0bject objLambda= () -> System. out. println("run")报错, 必须转化为-一个函数式接口
        Object obj = (Runnable) () -> System.out.println("run2");
    }

    //系统内置的一些函数式接口
    public static void main(String[] args) {
//        IntPredicate           int                  boolean
//         LongPredicate         long                boolean
//        DoublePredicate        double            boolean
//        Predicate<T>           参数T            返回值 boolean

//        Consumer<T>            参数T            返回值 void
//        IntConsumer            int          boolean
//        LongConsumer           long          boolean
//        DoubleConsumer double             boolean

        //Function<T,R>          参数T           返回值 R
//        IntFunction<R>         参数R           返回值R
//        ......
//        IntToDoubleFunction    int          double
//        ...

//        Supplier<T>            无参数            返回T
//        UnaryOperator<T> 继承Functioan   参数T          返回值 T
//        BinaryOperator<T>     参数 T T      返回参数是 T
//        BiFunction<T, U, R>   参数 T U    返回值 R
//        BiPredicate<T,U>      参数 T U        返回值 boolean
//        BiConsumer<T,U>       参数 T U        返回值 void
    }