Java Lambda表达式 ()->{}

为什么要使用lambda？

  1. 避免匿明内部类定义过多

  2. 让代码看起来简洁（有些类只用一次，用先定义对象，在new太麻烦）

  3. 去掉一堆没用的代码，只留核心逻辑

  4. 这是Java8才有的特性（函数式接口）

函数式接口定义

  1. 任何接口只包含一个抽象方法，那么他就是一个函数式接口

  2. 比如

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

  1. 对于函数式接口，我们可以用lambda表达式创建该接口对象

  2. 比如：a->System.out.println(“hello,Lamda”);

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

  4. (param)-> expression[表达式]

  5. (param)-> expression[语句]

  6. (param)-> {statements}

推导过程

一、最初做法

//
public class Lamda {
    public static void main(String\\\[\\\] args) {
        //3.new 对象，调用方法
        Student s = new Student();
        s.lambda();
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void lambda();
}
//2.实现接口
class Student implements Person{

    @Override
    public void lambda() {
        System.out.println("i am student");
    }
}

二、用静态内部类简化

public class Lamda {
    //2.静态内部类实现接口
    static class Student implements Person {
        @Override
        public void lambda() {
            System.out.println("i am student");
        }
    }
    public static void main(String\\\[\\\] args) {
        //3.new 对象，调用方法
        Student s = new Student();
        s.lambda();
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void lambda();
}

三、用局部内部类简化

public class Lamda {

    public static void main(String\\\[\\\] args) {
        //2.局部内部类实现接口
        class Student implements Person {
            @Override
            public void lambda() {
                System.out.println("i am student");
            }
        }

        //3.new 对象，调用方法
        Student s = new Student();
        s.lambda();
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void lambda();
}

四、匿明内部类简化

public class Lamda {

    public static void main(String\\\[\\\] args) {

        //2.创建匿名类
        Person p = new Person(){
            @Override
            //3.调用方法
            public void lambda() {
                System.out.println("i am student");
            }
        };
        //调用方法
        p.lambda();
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void lambda();
}

五、用lambda简化（必须是要函数式接口才行）

public class Lamda {

    public static void main(String\\\[\\\] args) {

        //2.lambda表达式
        Person p = ()->{
                System.out.println("i am student");
            };//注意 ';'
        //调用方法
        p.lambda();
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void lambda();
}

六、用lambda简化（带参数）

public class Lamda {

    public static void main(String\\\[\\\] args) {

        //3.带参数lambda表达式，当只有一个参数的时候可以不使用()
//        Person p = food->{
//            System.out.println("i eat " +food);
//        };//注意 ';'
        //也可以写成这样：
        Person p = food->System.out.println("i eat " +food);
        //调用方法
        p.eat("苹果！");


        //多个参数需要写（），这里的 String ...a是未知个数的参数Java 5开始的语法
        //Man man =(String food,String a)->{ 也可以写成一下形式
        Man man =(food,a)->{
            System.out.println("i eat "+food);
            //a 当做数组使用
            System.out.println("other params：");
//            for (int i=0;i<a.length;i++){
//                System.out.println(a\\\[i\\\]);
//            }
            for (String s : a) {
                System.out.println(s);
            }
        };
        //调用
        man.eat("草莓","茄子","玉米","西瓜","葡萄");
        //调用
        man.eat("草莓");
    }

}
//1.定义一个只有一个方法的接口
interface Person{
    void eat(String food);
}
//2.定义一个只有一个方法的接口
interface Man{
    void eat(String food,String ...a);
}

image.png