Java lambda表达式推导

1.为什么要使用Lmbda表达式

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

• 可以让你的代码看起来更简洁

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

2.理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在

函数式接口的定义：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

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

我们先来看一下这个代码：

package demo;

/*
* 推导lambda表达式
* */

public class lamdba {


    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        
    }
}




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

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

控制台结果：

i like lambda

下面是推导过程：

package demo;

/*
* 推导lambda表达式
* */

public class lamdba {

    //3. 静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
    	//2.普通
        ILike like = new Like();
        like.lambda();
		//3.静态
        ILike like2 = new Like2();
        like2.lambda();

        // 4.局部内部类
         class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        ILike like3 = new Like3();
         like3.lambda();

         //5.匿名内部类，没有类的名称，必须借助接口或者父类
        ILike like4 = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like4.lambda();


        //6. 用lambda简化
        ILike like5 = () -> {
            System.out.println("i like lambda5");
        };
        like5.lambda();

        //7.继续简化
        ILike like6 = () ->  System.out.println("i like lambda6");
        like6.lambda();



    }
}




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

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

控制台结果：

从局部内部类到匿名内部类这一部分可以看到局部内部类还是以实现ILike接口重写方法达到目的，但是转到匿名内部类来对比是不是把class Like3 implements ILike 这部分代码中ILike拿出来放到了new 后面，大家可以想你创建这个类是为了实现方法，而且是一个只有一个抽象方法的函数式接口，仔细想想就一个方法那名字好像就有点多余，因为不管上面类名都是为了实现这个方法，于是就有了下面这一写法（目的也是简化）。

我们从普通到静态内部类到局部内部类我就不说了，直接来看匿名内部类(这段代码是上面的一部分)：

 //5.匿名内部类，没有类的名称，必须借助接口或者父类
        ILike like4 = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like4.lambda();

我们利用接口ILike直接重写了lambda方法从而达到了目的，但是我们对比lambda来说，匿名内部类还是太长了点，还有改进简写的办法于是乎出现了下面这段代码。

//6. 用lambda简化
        ILike like5 = () -> {
            System.out.println("i like lambda5");
        };
        like5.lambda();

这时Java说你前面已经指明ILike了，里面只有一个方法，固定的我帮你写了该去的都去了留下你的参数和你重写方法要实现的逻辑吧，这样一来我们就只剩下() -> {System.out.println(“i like lambda5”);};参数写括号里，实现的逻辑写{}里，完事，最终再去掉{}。

 ILike like5 = () -> System.out.println("i like lambda5");

这就出现了lambda表达式，慢慢对比思考简化后的过程。