Lambda表达式

java是面向对象；

面向对象编程思想:做一件事情找一个能解决事情的对象，调用对象的方法，完成事情

函数式编程思想:他做一件事情，只要能获取结果，谁去做的，怎么做到都不重要，只重视结果，不重视过程

固然面向对象的方式，更容易让人理解，但是有时候代码过于冗余

class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "不错，是你");
    }
}
public class Demo01 {
    public static void main(String[] args) {
        //创建接口实现对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象
        Thread thread = new Thread(run);
        //调用start方法
        thread.start();
    }
}

我们还可以用匿名内部类

public class Demo01 {
    public static void main(String[] args) {

        //简化代码,使用匿名内部类
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "不错，是我");
            }
        }).start(); 
    }
}

其实核心的代码就是

System.out.println(Thread.currentThread().getName() + "不错，是我");

过于冗余

我们来看看Lambda表达式

public class Demo02Lambda {
    public static void main(String[] args) {
        //使用Lambda表达式表示多线程

        new Thread(()-> {
            System.out.println(Thread.currentThread().getName() + "不错，是我");
        }).start();
    }
}

​ Lambda表达式的标准格式:

​ 由三部分组成:

​ a.一些参数

​ b.一个箭头

​ c.一段代码

​ 格式:

​ (参数列表) -> {一些重写方法的代码};

​ 解释说明格式:

​ ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔

​ ->:传递的意思,把参数传递给方法体{}

​ {}:重写接口的抽象方法的方法体

无参无返回

package Demo06Lambda;
interface Cook{
    //无参数无返回值方法
    abstract void makeFood();
}
public class Demo03 {
    public static void main(String[] args) {
        //调用invokeCook方法，参数是接口
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦");
            }
        });
        //使用lambda表达式，简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("喝水啦");
        });
    }
    //定义一个方法传递cook接口，方法内部调用接口方法makefood
    public static void invokeCook(Cook c) {
        c.makeFood();
    }
}

有参数有返回

package Demo06Lambda;

interface Calculator{
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int calc(int a,int b);
}

public class Demo05 {
    public static void main(String[] args) {
        //使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //使用lambda表达式
        invokeCalc(10,20,((a, b) -> {return a-b;}));
    }
    //定义一个方法，参数传递Calculator方法内部调用calc计算两个整数和
    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

        Arrays.sort(arr, (Person o1,Person o2)-> {
            return o2.getAge() - o1.getAge();
        });

在这个代码中点击查看sort源代码

public static  void sort(T[] a, Comparator c) {
    if (c == null) {
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

原来他必须传递一个Comparator类

最后小总结有且仅有一个抽象方法的接口称为函数式接口