Lambda 表达式怎么用?

Posted 2023-02-04 Kirl z

Lambda 表达式怎么用?

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

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

Lambda 表达式语法

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

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");
    

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

public class TestLambda 
    public static void main(String[] args) 
        new Thread(new Runnable() 
            @Override
            public void run() 
                System.out.println("testLambda");
            
        ).start();
    

这里 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();
    

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

public class TestLambda 
    public static void main(String[] args) 
        new Thread(() -> System.out.println("Hello")).start();
    

自定义接口的使用

// 定义一个接口
public interface MyInterface 

    void test(String s);

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

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);
    

函数式接口

对于只有一个抽象方法的接口（可以有默认方法，或者静态方法和从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);

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

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

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

而且，

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