Lambda 表达式怎么用?

Lambda 表达式怎么用?

Lambda 表达式就是对匿名内部类的一个写法的改变。lambda 表达式允许讲一个函数作为另一个函数的参数。

当前这个类的使用过程, 不想写在别的地方, 写在当前类中,可以用到当前类的属性。

Lambda 表达式语法

(parameters) -> { statements; }
// parameters 参数（不需要声明类型），可为空
// statements 方法体
1
2
3

Lambda 表达式使用

Runnable接口的使用

public class TestLambda {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("testLambda");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以使用 lambda表达式使这段代码变得更加简洁，可以使用匿名内部类重构代码

public class TestLambda {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("testLambda");
            }
        }).start();
    }
}
1
2
3
4
5
6
7
8
9
10

这里 new Runnable()，new 了接口，在这个new 的接口里面， 我们写了这个接口的实现类。

这里重写了 run() 方法传入了一个构造函数

上面的代码可以换成这样的，我们将new 的接口，赋值给线程的引用：

public class TestLambda {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello");
            }
        });
        thread.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11

而上面的代码，可以使用 lambda 表达式进一步简化

public class TestLambda {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello")).start();
    }
}
1
2
3
4
5

自定义接口的使用

// 定义一个接口
public interface MyInterface {

    void test(String s);

}
1
2
3
4
5
6

接口需要实现，需要一个子类

public class Test {
    public void method(MyInterface m) {
        // m 是 MyInterface 的一个子类
        // 多肽的效果，子类对象执行的test方法
        m.test("test");
    }

    public static void main(String[] args) {
        // 测试
        Son son = new Son();
        son.test("test");

        // 多肽写法
        MyInterface myInterface = new Son();
        son.test("test");

        // 匿名内部类
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public void test(String s) {
                System.out.println("子类重写方法" + s);
            }
        };
        myInterface1.test("test");

        // lambda 表达式
        MyInterface myInterface2 = s -> {
            System.out.println("子类重写方法" + s);
        };
        myInterface2.test("test");

        // ==================
        Test t = new Test();
        t.method(s -> {
            System.out.println("子类重写方法" + s);
        });
    }
}


// 子类 内部类
class Son implements MyInterface {
    // 方法重写
    @Override
    public void test(String s) {
        System.out.println("子类重写方法" + s);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

函数式接口

对于只有一个抽象方法的接口（可以有默认方法，或者静态方法和从Object继承来的的方法）称为函数式接口，可以使用lambda表达式进行赋值。

JDK8之后添加@FunctionalInterface表示这个接口是是一个函数式接口

@FunctionalInterface
java.lang.Runnable{
    void run();
}
	   
@FunctionalInterface
java.lang.Comparator<T>{
	int compare(T o1, T o2);
}
 
@FunctionalInterface
public interface Function<T, R> {
	R apply(T t);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

每一个 Lambda 表达式都能够隐式的给函数式接口赋值

new Thread(() -> System.out.println("hello")).start();
1

上面这个例子，编译器会认为 Thread() 中传入的是一个 Runnable 的对象，而实际上这是一个 Runnable 类型，实际上编译器会自动将 lambda 表达式赋值给函数式接口，在本例中就是Runnable接口。本例中Lambda表达式将打印方法传递给了Runnable接口中的run（）方法，从而形成真正的方法体。

而且，

参数与返回值是一一对应的，即如果函数式接口中的抽象方法是有返回值，有参数的，那么要求Lambda表达式也是有返回值，有参数的（余下类推