Lambda 表达式

​ ​ ​ ​ ​ ​ ​ ​ Lambda 表达式的实质属于函数式编程。

​ ​ ​ ​ ​ ​ ​ ​ 语法格式为：(parameters) -> expression或(parameters) ->{statements; }
​ ​ ​ ​ ​ ​ ​ ​

Lambda 表达式的特点

• Lambda 表达式只能引用标记了 final 的外层局部变量
• 不能在lambda 内部修改定义在域外的局部变量
• Lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（自带 final）
• Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量
  ​ ​ ​ ​ ​ ​ ​ ​

Lambda 表达式的作用

• 避免匿名内部类定义过多
• 让代码更简洁，只留下核心逻辑
  ​ ​ ​

函数式接口

​ ​ ​ ​ ​ ​ ​ ​ 函数式接口 Functional Interface，是只包含唯一一个抽象方法的接口。对于函数式接口，可以通过 Lambda 表达式来直接创建该接口的对象。如 Runnable 接口：

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

使用 Lambda 表达式实现 Runnable

//常规写法
new Thread(new Runnable(){
    @Override
    public void run(){
        ...
    }
}).start();

//Lambda 表达式
new Thread( () -> {
    ...
}).start();

​ ​ ​ ​ ​ ​ ​ ​
JDK 1.8之前已有的函数式接口：

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

• java.util.function

​ ​ ​ ​ ​ ​ ​ ​

Lambda 表达式的简化过程

​ ​ ​ ​ ​ ​ ​ ​ 实现类–>静态内部类–>局部内部类–>匿名内部类–>Lambda 表达式

​ ​ ​ ​ ​ ​ ​ ​ 简化过程如下：

实现类

public class TestLamda01 {
	public static void main(String[] args) {
    DoSports jog = new Jog();
    }
}

interface DoSports{
    void start();
}

//实现类
class Jog1 implements DoSports{
    @Override
    public void start() {
        System.out.println("I"m jogging");
    }
}

静态内部类

public class TestLambda01 {
	//静态内部类
    static class Jog implements DoSports{
        public void start(){
            System.out.println("I"m jogging");
        }
    }

    public static void main(String[] args) {
        DoSports jog = new Jog();
        jog.start();
    }
}

interface DoSports{
    void start();
}

局部内部类

public class TestLambda01 {

    public static void main(String[] args) {
		//局部内部类
        class Jog implements DoSports{
            public void start(){
                System.out.println("I"m jogging");
            }
        }
        DoSports jog = new Jog();
        jog.start();
    }
}

interface DoSports{
    void start();
}

匿名内部类

public class TestLambda01 {

    public static void main(String[] args) {


        DoSports jog = new DoSports(){
            public void start(){
                System.out.println("I"m jogging");
            }
        };
        jog.start();
    }
}

interface DoSports{
    void start();
}

​ ​ ​ ​ ​ ​ ​ ​
Lambda 表达式

public class TestLambda01 {

    public static void main(String[] args) {
        
        DoSports jog = ()->{
            System.out.println("I"m jogging"); //start() 方法执行主体
        };
        jog.start();
    }
}

interface DoSports{
    void start();
}

含参数的 Lambda 表达式简化

​ ​ ​ ​ ​ ​ ​ ​ 当只有一个参数时，可简化参数类型和括号

public class TestLambda01 {

    public static void main(String[] args) {
        /*可简化参数类型和括号
        DoSports jog = (int a)->{
            ...
        };*/
        DoSports jog = a->{
            //start() 方法执行主体
            ...
        };
        jog.start(参数1);
    }
}

interface DoSports{
    void start(int a);
}

​ ​ ​ ​ ​ ​ ​ ​ 当有多个参数时，可简化参数类型，必须加括号

public class TestLambda01 {

    public static void main(String[] args) {
        /*可简化参数类型和括号
        DoSports jog = (int a,String b)->{
            ...
        };*/
        DoSports jog = (a,b)->{
            //start() 方法执行主体
            ...
        };
        jog.start(参数1,参数2);
    }
}

interface DoSports{
    void start(int a,String b);
}