Lamda表达式

Lamda表达式

原文链接：《遇见狂神说》P10 多线程10：Lamda表达式

1.1 介绍

• λ 希腊字母表中排序第十一位的字母，英语名称为 Lamda

• lambda表达式是jdk8中引进的概念。

• Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

• 使用 Lambda 表达式可以使代码变的更加简洁紧凑。

• λ表达式本质上是一个匿名方法。

1.2 作用

• 避免匿名内部类定义过多

• 其实质属于函数式编程的概念

• 去掉了一堆没有意义的代码,只留下核心逻辑

1.3 语法

基本语法:

(parameters) -> expression
或
(parameters) ->{ statements; }

1.4 lambda表达式的简单例子

// 1. 不需要参数,返回值为 5
() -> 5
 
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
 
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
 
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
 
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

// 6.线程中使用打印文字
new Thread (()->System.out.println(“多线程学习。。。。”)).start();

1.5 补存：函数式接口的定义

任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口

比如：Runnable接口

public interface Runnable {
    public abstract void run();
}

对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象。

1.6 案例实现

1.6.1 案例1

初始代码：

package com.rr;

/**
 * 推导lamda表达式
 */
public class Demo9_Lamda {
    public static void main(String[] args) {
        ILike iLike = new Like();
        iLike.lamda();
    }
}

// 1.定义一个函数式接口
interface ILike {
    void lamda();
}

// 2.实现类
class Like implements ILike {
    @Override
    public void lamda() {
        System.out.println("I like lamda");
    }
}

优化1：使用静态内部类

其中ILike是之前的接口，下面直接调用。

package com.rr;

public class Demo10_Lamda {
    //3. 静态内部类
    static class Like1 implements ILike {
        @Override
        public void lamda() {
            System.out.println("I like lamda1");
        }
    }
    //3.静态内部类
    public static void main(String[] args) {
        ILike like = new Like1();
        like.lamda();
    }
}

优化2：使用局部内部类

其中ILike是之前的接口，下面直接调用。

package com.rr;

public class Demo11_Lamda {
    public static void main(String[] args) {
        //4.局部内部类
        class Like12 implements ILike {
            @Override
            public void lamda() {
                System.out.println("I like lamda2");
            }
        }
        ILike like = new Like12();
        like.lamda();
    }
}

优化3：匿名内部类,没有类的名称,必须借助接口或者父类

其中ILike是之前的接口，下面直接调用。

package com.rr;

public class Demo12_Lamda3 {
    public static void main(String[] args) {
        //5.匿名内部类,没有类的名称,必须借助接口或者父类
        ILike like = new ILike () {
            @Override
            public void lamda() {
                System.out.println("I like lamda3");
            }
        };
        like.lamda();
    }
}

最终版：lamda简化

其中ILike是之前的接口，下面直接调用。

package com.rr;

public class Demo13_Lamda {
    public static void main(String[] args) {
        //6.lamda简化
        ILike like = () ->{
            System.out.println("I like lamda4");
        };
        like.lamda();
    }
}

1.6.2 案例2

package com.rr;

public class Demo14_LamdaCase {
    public static void main(String[] args) {
        // 1.lamda
        ILove love = (int a) -> {
            System.out.println("I love you -->" + a);
        };
        // 2.lamda简化1.0
        love = (a) -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化2.0
        love = a -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化3.0
        love = a -> System.out.println("I love you -->" + a);
        
        love.love(520);

    }
}

interface ILove {
    void love(int a);
}

总结：

• {}简略的条件是只能有一行代码,多行{}就不能简略了
• 前提是接口为函数式接口(只能有一个方法)
• 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()