Lambda表达式的演变

1，Lambda表达式简介

• 希腊字母表中排序第十一的字母，英语名称为Lambda
• 避免匿名内部类定义过多
• 实质属于函数式编程的概念
• 可以让你的代码看起来更加简介
• 去掉一些没有意义的代码，只留下核心的逻辑

举个简单的例子：

new Thread(()->System.out.println(\"Lambda表达式学习~~~")).start();

• tip:不过，在理解lambda表达式之前，你可能要先知道什么是函数式接口.....

2 函数式接口

定义：任何接口，如果只包含唯一的一个抽象方法，那么，它就是一个函数式接口。
举个例子：我们所熟悉的Runnable接口，就是一个函数式接口，如下：

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

对于函数式接口，我们可以通过lambda表达式来创建接口的对象：

3 具体演变

• 1，最普遍的做法，通过接口创建一个实现类的对象，再调用实现类的方法：

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = new Like();
        ilike.lambda();
    }
}

interface Ilike {
    void lambda();
}

class Like implements Ilike {

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

• 2，稍微优化，将以上做法，写成静态内部类的形式，如下：

public class TestLambda {
    static class Like implements Ilike {
        @Override
        public void lambda() {
            System.out.println("I like Lambda !");
        }
    }

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

interface Ilike {
    void lambda();
}

• 3，再次优化一下，将以上做法，写成局部内部类的形式，如下：

public class TestLambda {
    public static void main(String[] args) {
        class Like implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like Lambda !");
            }
        }

        ILike ilike = new Like();
        ilike.lambda();
    }

    interface ILike {
        void lambda();
    }
}

• 4，继续优化，通过匿名内部类来实现，会更加简化，如下：

定义：匿名内部类：没有类的名称，必须借助接口或者父类。

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda !");
            }
        };
        ilike.lambda();
    }
}

interface Ilike {
    void lambda();
}

• 5，继续用简化，使用Lambda，如下：

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = () -> {
            System.out.println("I like L ambda !");
        };
        ilike.lambda();
    }
}

interface Ilike {
    void lambda();
}

4 具体演变--带参数的情况

ps：以下情况类似无参数情形，不做过多解释。

• 第一步：

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = new Like();
        ilike.lambda("Apricity");
    }
}

interface Ilike {
    void lambda(String name);
}

class Like implements Ilike {
    @Override
    public void lambda(String name) {
        System.out.println("I like " + name);
    }
}

• 第二步：

public class TestLambda {
    static class Like implements Ilike {
        @Override
        public void Lambda(String name) {
            System.out.println("I like " + name);
        }

        public static void main(String[] args) {
            Ilike ilike = new Like();
            ilike.Lambda("Apricity");
        }
    }

    interface Ilike {
        void Lambda(String name);
    }
}

• 第三步：

public class TestLambda {
    public static void main(String[] args) {
        class Like implements Ilike {
            @Override
            public void lambda(String name) {
                System.out.println("I like " + name);
            }
        }
        Ilike ilike = new Like();
        ilike.lambda("Apricity");
    }
}

interface Ilike {
    void lambda(String name);
}

• 第四步：

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = new Ilike() {
            @Override
            public void lambda(String name) {
                System.out.println("I like  " + name);
            }
        };
        ilike.lambda("Apricity");
    }
}

interface Ilike {
    void lambda(String name);
}

• 第五步：

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = (name) -> {
            System.out.println("I like " + name);
        };
        ilike.Lambda("Apricity");
    }
}

interface Ilike {
    void Lambda(String name);
}

• 第六步：甚至可以将参数的括号和参数类型去掉，但是，能简化到这种程度的条件是函数的参数只能有一个，如果有多个，还是要将括号加上！

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = name -> {
            System.out.println("I like " + name);
        };
        ilike.Lambda("Apricity");
    }
}

interface Ilike {
    void Lambda(String name);
}

• 第七步：甚至可以将执行体去掉，但是，能简化到这种程度的条件时实现的代码只能有一行

public class TestLambda {
    public static void main(String[] args) {
        Ilike ilike = name -> System.out.println("I like " + name);
        ilike.lambda("Apricity");
    }
}

interface Ilike {
    void lambda(String name);
}