Lambda表达式的演变历程(含代码讲解)

首先,我们知道什么是lambda表达式.
为什么我们需要使用到Lambda表达式?
在jdk1.8之前是没有Lambda式的,最原始就是创建一个类,一个接口,一个实现类,实现类中实现逻辑代码,但是接口过多,实现类过多,类也多, 其中只要一个方法体的接口,的实现类就会有很多重复的代码.进而为了优化这一现象,才推出了Lambda表达式,当然Lambda表达式不是凭空出来的,也是经过代码简化的一步一步实现过来的.
代码:

package com.qiu.Lambda;
/*
推导lambda表达式
 */
public class TestLambda {
        //3.静态内部类
   static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        ILike like2 = new Like2();
        like2.lambda();

        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类:没有类的名称,必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();
        //6.用Lambda表达式简化
        like = () ->{
            System.out.println("i like lambda5");
        };
        like.lambda();
    }

}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{

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

代码中1->6就是逐渐简化的过程.

第一步:

package com.qiu.Lambda;

public class TestLambda01 {
    public static void main(String[] args) {
        ILove love= new Love();
        love.love(1);
    }
}
interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("i love you:"+a );
    }
}

第二步:将实现类变成静态实现类:

package com.qiu.Lambda;

public class TestLambda01 {
    static class Love implements ILove{
        @Override
        public void love(int a) {
            System.out.println("i love you:"+a );
        }
    }
    public static void main(String[] args) {
        ILove love= new Love();
        love.love(1);
    }
}
interface ILove{
    void love(int a);
}

第三步:将静态实现类放入局部内部类

package com.qiu.Lambda;

public class TestLambda01 {

    public static void main(String[] args) {

         class Love implements ILove{
            @Override
            public void love(int a) {
                System.out.println("i love you:"+a );
            }
        }
        ILove love= new Love();
        love.love(5);
    }
}
interface ILove{
    void love(int a);
}

第四步:将局部内部类转成匿名内部类(通过接口去实现):

package com.qiu.Lambda;

public class TestLambda01 {

    public static void main(String[] args) {
        ILove love= new ILove() {
        @Override
        public void love(int a) {
            System.out.println("i love you:"+a );
            }
        };
        love.love(6);
    }
}
interface ILove{
    void love(int a);
}

第五步:进而推导Lambda表达式(类,接口,方法去掉)

package com.qiu.Lambda;

public class TestLambda01 {

    public static void main(String[] args) {
        ILove love = (int a)-> {
            System.out.println("i love you:"+a );
        };
        love.love(6);
    }
}
interface ILove{
    void love(int a);
}

第五步:再简化!

package com.qiu.Lambda;

public class TestLambda01 {

    public static void main(String[] args) {
        ILove love =null;
        //Lambda表达式简化
        ILove love1= (int a)-> {
            System.out.println("i love you:"+a );
        };
        //简化1.去掉参数类型
        love = (a)-> System.out.println("i love you:"+a );

        //简化2.简化括号
        love= a -> {
            System.out.println("i love you:"+a );
        };
        //简化3.去掉花括号
        love = a -> System.out.println("i love you:"+a);

        /*
        总结:
        1.Lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码快包裹
        2.前提:必须是函数式接口,接口里面只有一个方法
        3.多个参数可以去掉参数类型,要去掉就必须都去掉,多个参数去类型后,必须加上括号.
         */

        love.love(6);
    }
}
interface ILove{
    void love(int a);
}

总结:
1.Lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码快包裹
2.前提:必须是函数式接口,接口里面只有一个方法
3.多个参数可以去掉参数类型,要去掉就必须都去掉,多个参数去类型后,必须加上括号.