Lambda表达式（1）

准备工作

先准备一个类用作产生我们的数据，新建一个POJO（Plain Ordinary Java Object）——Apple

class Apple{
    private String id;
    private float weight;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public float getWeight() {
        return weight;
    }

    public void setWeight(float weight) {
        this.weight = weight;
    }

    public Apple() {
    }

    public Apple(String id, float weight) {
        this.id = id;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "id='" + id + '\'' +
                ", weight=" + weight +
                '}';
    }
}

什么是Lambda

1. 从一个排序的例子说起

我们如果想按照苹果的重量（weight）从小到大对一批苹果进行排序，我们一种做法是使用
List的void sort(Comparator<? super E> c)方法，可以看到这一方法需要传入一个Comparator对象来指定排序规则。
Comparator是一个抽象类，所以需要写一个实现类，在方法conpare中制定排序规则，然后再新建一个实例对象传到sort方法中。

• 接口Comparator的实现类

class ComparatorImpl<T> implements Comparator<T> {

    @Override
    public int compare(T o1, T o2) {
        Apple a1 = (Apple)o1;
        Apple a2 = (Apple)o2;
        
        if (a1.getWeight() > a2.getWeight())
            return 1;
        else if (a1.getWeight() == a2.getWeight())
            return 0;
        return -1;
    }
}

• 使用Comparator的实现类ComparatorImpl

    public static void main(String[] args) {
        List<Apple> apples = Arrays.asList(
                new Apple("apple1", 100.0f),
                new Apple("apple2", 103.2f),
                new Apple("apple3", 101.2f),
                new Apple("apple4", 100.0f)
        );

        // 排序
        Comparator<Apple> c = new ComparatorImpl<>();
        apples.sort(c);

        System.out.println(apples);
    }

2. 匿名对象

上面的例子有没有让你感觉到反感，我就想排个序，为什么我还需要先写一个实现类，在创建一个该类的对象，然后当作参数传入到sort方法中实现排序。能不能简单点？
Yes，其实我们不用单独建一个类，我们可以使用匿名对象，直接在sort方法的实参中创建一个没有名称的对象，看看实例

    public static void main(String[] args) {
        List<Apple> apples = Arrays.asList(
                new Apple("apple1", 100.0f),
                new Apple("apple2", 103.2f),
                new Apple("apple3", 101.2f),
                new Apple("apple4", 100.0f)
        );

        // 排序
        apples.sort(new Comparator<Apple>() {

            @Override
            public int compare(Apple a1, Apple a2) {
                if (a1.getWeight() > a2.getWeight())
                    return 1;
                else if (a1.getWeight() == a2.getWeight())
                    return 0;
                return -1;
            }
        });

        System.out.println(apples);
    }

3. Lambda表达式

其实也并没有减轻多少负担，还是这么的啰嗦，其实Comparator中主要的部分就是那个制定排序规则的conpare方法，要是能直接将compare这个方法体作为参数传递给sort方法就好了，主角出场了——java8中的Lambda就可以满足你。

image.png

这里的内容参考了这一博文的内容
作者：Sevenvidia
来源：https://www.zhihu.com/question/20125256/answer/324121308

现在看看我们清爽的代码

    public static void main(String[] args) {
        List<Apple> apples = Arrays.asList(
                new Apple("apple1", 100.0f),
                new Apple("apple2", 103.2f),
                new Apple("apple3", 101.2f),
                new Apple("apple4", 100.0f)
        );

        // 排序
        apples.sort((a1, a2) -> {
            if (a1.getWeight() > a2.getWeight())
                return 1;
            else if (a1.getWeight() == a2.getWeight())
                return 0;
            return -1;
        });

        System.out.println(apples);
    }

总结

这篇博文通过一个比较的例子引入Lambda表达式，关键点在于：

1. Lambda表达式可以理解为匿名对象的简化方式
2. Lambda表达式的实质依旧是一个对象，他不是将一个方法赋值给一个变量，尽管看起来很像
3. Lambda表达式是某一接口的实现类。在文中的例子中，

(a1, a2) -> {
            if (a1.getWeight() > a2.getWeight())
                return 1;
            else if (a1.getWeight() == a2.getWeight())
                return 0;
            return -1;
        }

这一Lambda表达式是Comparator这一接口的实现。