JavaSE学习笔记：Lambda表达式

一、基本概念和思想

• 面向对象：做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
• 函数式编程思想:只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

二、冗余的Runnable代码

• 实现多线程的方法二，实现Runnable接口，重写run方法
• 下面用三种方式实现在多线程中实现同一个功能

public class Demo1Runnable {
    public static void main(String[] args) {
        //方案1
        RunnableImpl runnable = new RunnableImpl();
        Thread t = new Thread(runnable);
        t.start();

        //2.匿名内部类
        Runnable runnable1 = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "->正在执行");
            }
        };
        Thread t1 = new Thread(runnable1);
        t1.start();

        //3.简化的匿名内部类实现
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "->正在执行");
            }
        }).start();

    }
}

• 上述代码的核心其实只有一句：System.out.println(Thread.currentThread().getName() + "->正在执行");

三、Lambda改进上述写法

public class Demo2Lambda {
    public static void main(String[] args) {
        //3.简化的匿名内部类实现
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "->正在执行");
            }
        }).start();

        //4.lambda表达式改进写法
        new Thread(
                ()->System.out.println(Thread.currentThread().getName() + "->正在执行")
        ).start();
    }
}

3.1Lambda的标准写法

Lambda表达式的标准格式:

• 由三部分组成:
  • a.一些参数
  • b.一个箭头
  • c.一段代码
• 格式:
  • (参数列表) -> {一些重写方法的代码};
  • 解释说明格式:
  • ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
  • ->:传递的意思,把参数传递给方法体{}
  • {}:重写接口的抽象方法的方法体

3.2Lambda无参数无返回值的写法

需求:

• 给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
• 使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样

public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}
public class Demo01Cook {
    public static void main(String[] args) {
        //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });

        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });

        //优化省略Lambda
        invokeCook(()-> System.out.println("吃饭了"));
    }

    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

3.3Lambda的有参数有返回值的写法

需求:

• 给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
• 使用Lambda的标准格式调用invokeCalc方法，完成相加计算

public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int calc(int a,int b);
}
public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });

        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a + b;
        });

        //优化省略Lambda
        invokeCalc(120,130,(a,b)-> a + b);
    }

    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法内部调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

四、Lambda的省略格式

Lambda表达式:是可推导,可以省略

• 凡是根据上下文推导出来的内容,都可以省略书写
• 可以省略的内容:
  1.(参数列表):括号中参数列表的数据类型,可以省略不写
  2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
  3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
  • 注意:要省略{},return,分号必须一起省略

五、Lambda的使用前提

• 1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
  • 无论是JDK内置的Runnable 、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一
    时，才可以使用Lambda
• 2.使用Lambda必须具有上下文推断。
  • 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。