Lambda表达式与方法引用学习

java的Lambda表达式和方法引用入门学习：

---

Lambda表达式的本质

作为接口的实例，且该接口必须是函数式接口

基本语法格式

(o1,o2) -> Integer.compare(o1,o2);

格式说明：
-> ：lambda操作符或箭头操作符
->左边：lambda形参列表(其实就是接口中的抽象方法的形参列表)
->右边：lambda体(其实就是重写的抽象方法的方法体)

---

lambda表达式的使用

1. 接口重写方法无参，无返回值

public void test(){
        //原始写法
        Runnable r1 = new Runnable() {
            public void run() {
                System.out.println("原始写法");
            }
        };

        //lambda表达式写法
        Runnable r2 = () -> {
        	System.out.println("lambda表达式写法");
        };
}

2. 接口重写方法有一个参数，无返回值

public static void test(){
        //原始写法
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("这是原始写法"+s);
            }
        };

        //lambda表达式写法
        Consumer<String> co = (String s) -> {
            System.out.println("这是lambda表达式写法"+s);
        };
    }

这里数据类型可以省略，因为可由编译器推断得出，所以可以将上面的lambda表达式的写法更精简些

public static void test(){
        //原始写法
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("这是原始写法"+s);
            }
        };

        //lambda表达式写法
        Consumer<String> co = (String s) -> {
            System.out.println("这是lambda表达式写法"+s);
        };
        //精简的lambda表达式写法
        Consumer<String> c = (s) -> {
            System.out.println("这是精简的lambda表达式写法"+s);
        };
    }

若重写方法只需一个参数，参数的小括号也可以省略

public static void test(){
        //原始写法
        Consumer<String> cons = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("这是原始写法"+s);
            }
        };

        //lambda表达式写法
        Consumer<String> con = (String s) -> {
            System.out.println("这是lambda表达式写法"+s);
        };
        //精简的lambda表达式写法
        Consumer<String> co = (s) -> {
            System.out.println("这是精简的lambda表达式写法"+s);
        };
        //省略小括号的lambda表达式写法
        Consumer<String> c = s -> {
            System.out.println("这是省略小括号的lambda表达式写法"+s);
        };
    }

3. 接口重写方法需要两个或两个以上的参数，多条执行语句，并且可以有返回值

public void test(){
        //原始写法
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        //lambda表达式写法
        Comparator<Integer> co = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
    }

4. 接口重写方法的方法体只有一条语句时，return与大括号若有，都可以省略

public void test(){
        //原始写法
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };

        //lambda表达式写法
        Comparator<Integer> co = (o1,o2) -> o1.compareTo(o2);
    }

方法引用

介绍

使用场景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
是什么：方法引用可以看作是Lambda表达式深层次的表达，换句话说，方法引用就是Lambda表达式
要求：实现接口的抽象方法的参数列表和返回值类型必须与方法引用的方法的参数列和返回值类型保持一致

格式

类(或对象) :: 方法名
具体分为如下三种情况
	对象 :: 非静态方法
	类 :: 静态方法
	类 :: 非静态方法  

使用方式

1. 对象 :: 实例方法

public void test(){
        //原始写法
        Consumer<String> cons = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        
        //lambda表达式写法
        Consumer<String> con = str -> System.out.println(str);

        //方法引用的写法
        PrintStream ps = System.out;
        Consumer<String> co = ps :: println;
    }

2. 类 :: 静态方法

public void test(){
        //原始写法
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        //lambda表达式写法
        Comparator<Integer> co = (o1,o2) -> Integer.compare(o1,o2);

        //方法引用的写法
        Comparator<Integer> c = Integer :: compare;
    }

3. 类 :: 实例方法

	注意：这种方式的方法引用不必遵循前面方法引用的要求，这样的方式是要遵循下面的要求即可使用
		接口的抽象方法的第一个参数作为已实现的方法的调用者时，且返回值类型要与接口的抽象方法的返回值类型一致

public void test(){
        //原始写法
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };

        //lambda表达式写法
        Comparator<Integer> co = (o1,o2) -> o1.compareTo(o2);

        //方法引用的写法
        Comparator<Integer> c = Integer :: compareTo;
    }