在Java8之前，我们实现一个简单的、仅有一个方法的接口或者将一个简单的功能作为方法参数时，需要实例化一个匿名类对象，但是它看起来臃肿且不直观。
现在，Java8提供了Lambda表达式简化了上述操作。Lambda可以将方法或者代码片段作为数据进行参数传递。

接下来通过一个简单的场景来初识Lambda。

场景

假设有一个社交应用，系统管理员将对部分用户进行管理操作。接下来我们将使用Lambda表达式实现这个场景。

系统管理员在登陆之后，需要执行以下几个步骤：

1. 填写用户查询条件；
2. 然后设置一个操作；
3. 点击提交按钮提交以上数据；
4. 系统查询符合条件的用户；
5. 接着对这些用户执行管理员设置的操作。

实现

一点准备

下面这个Person就表示用户实体，其中createRoster方法模拟系统中所有用户数据。

import java.time.LocalDate;
import java.time.chrono.IsoChronology;
import java.util.ArrayList;
import java.util.List;

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    Person(String nameArg, LocalDate birthdayArg, Sex genderArg, String emailArg) {
        name = nameArg;
        birthday = birthdayArg;
        gender = genderArg;
        emailAddress = emailArg;
    }

    public int getAge() {
        return birthday.until(IsoChronology.INSTANCE.dateNow()).getYears();
    }

    public void printPerson() {
        System.out.println(name + ", " + this.getAge());
    }

    public Sex getGender() {
        return gender;
    }

    public String getName() {
        return name;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }

    public static List<Person> createRoster() {
        List<Person> roster = new ArrayList<>();
        roster.add(new Person("Fred", IsoChronology.INSTANCE.date(1980, 6, 20), Person.Sex.MALE, "fred@example.com"));
        roster.add(new Person("Jane", IsoChronology.INSTANCE.date(1990, 7, 15), Person.Sex.FEMALE, "jane@example.com"));
        roster.add(new Person("George", IsoChronology.INSTANCE.date(1991, 8, 13), Person.Sex.MALE, "george@example.com"));
        roster.add(new Person("Bob", IsoChronology.INSTANCE.date(2000, 9, 12), Person.Sex.MALE, "bob@example.com"));
        return roster;
    }

}

通常的做法

管理员可以指定用户的一个属性作为查询条件并打印用户信息，比如打印超过某个年龄的用户信息，如下实现方式很快就浮现在脑海中：

public static void printPersonsOlderThan(List<Person> roster, int age) {
    for (Person p : roster) {
        if (p.getAge() >= age) {
            p.printPerson();
        }
    }
}

更多条件

可以看到，printPersonsOlderThan方法实现了这个功能，但是管理员想打印一个年龄段内的所有用户，那么上面的实现就不能满足，所以需要定义一个新的方法：

public static void printPersonsWithinAgeRange(
            List<Person> roster, int low, int high) {
    for (Person p : roster) {
        if (low <= p.getAge() && p.getAge() < high) {
            p.printPerson();
        }
    }
}

printPersonsWithinAgeRange方法通过传入一个最小年龄和一个最大年龄实现了年龄段这种查询方式。

分析printPersonsOlderThan和printPersonsWithinAgeRange，发现一个问题，如果管理员想要结合年龄段和性别进行操作，或者Person类发生了变化，那么查询算法也需要重新编写，代码应对需求的变化显得十分脆弱。

进行一些改进

创建一个接口，实现这个接口筛选符合条件的用户。

interface CheckPerson {
    boolean test(Person p);
}

我们不再使用具体的属性作为参数进行查询，而是通过实现CheckPerson中的test方法匹配数据，下面这个类完成了对年龄段这个查询条件的封装：

class CheckPersonEligibleForSelectiveService implements CheckPerson {
    public boolean test(Person p) {
        return p.gender == Person.Sex.MALE &&
            p.getAge() >= 18 &&
            p.getAge() <= 25;
    }
}

接着定义一个比较健壮的方法实现查询打印：

public static void printPersons(
    List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

构造一个查询条件对象传入printPersons方法里：

printPersons(Person.createRoster(), new CheckPersonEligibleForSelectiveService());

这种方式看起来已经比之前的方式好多了，通过test方法的返回值来确定是否符合打印条件，这样我们的API就稳定了下来，即使查询条件变化也不需要修改这个方法了，只要根据管理员的请求构造不同的CheckPerson实例即可。

使用匿名类

printPersons中我们传入一个CheckPersonEligibleForSelectiveService的实例化对象作为查询条件，有时也会使用匿名类来完成和上面调用类似的方式：

printPersons(roster, new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

匿名类可以帮助我们不用去定义一个单独的实现类，这减少了一定的代码量，不过匿名类还是看起来很笨拙。

Lambda亮相

可以看到CheckPerson只有一个方法，我们可以称CheckPerson为一个函数式（functional interface）接口。一个函数式接口仅有一个抽象方法，因此在实现这个方法时可以省略掉方法名称，使用Lambda表达式来替换匿名类的用法：

printPersons(roster,
    (Person p) -> p.getGender() == Person.Sex.MALE 
        && p.getAge() >= 18 
        && p.getAge() <= 25
);

使用Lambda表达式的调用方式看起来是不是简明了许多。

不用造轮子

回顾CheckPerson，只有一个传入一个参数，然后返回一个布尔值的方法，其实它的功能很简单而且用途广泛，JDK的研发人员也是考虑到了这个问题，于是乎增加一个标准函数接口Predicate：

interface Predicate<T> {
    boolean test(T t);
}

观察这个接口不难发现，它同样是传入一个参数，返回了一个布尔值，完全可以用它替换CheckPerson，减少不必要的代码，实现完全相同的效果：

public static void printPersonsWithPredicate(
    List<Person> roster, Predicate<Person> tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

Predicate是一个泛型接口，在实例化这个接口的时候，需要指定一个泛型参数类型。如果指定泛型参数为Person类型，那么Predicate<Person>的方法签名可以看做是boolean test(Person t)，这和CheckPerson里的方法看起来一模一样，所以这样调用即可：

printPersonsWithPredicate(roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25
);

JDK8中还有很多类似Predicate这样的标准函数接口。

继续使用Lambda

看看printPersonsWithPredicate，它可以根据查询条件打印用户信息。但是管理员的操作不仅限于查询，也可能会有删除或者其他的动作。所以继续使用Lambda。

之前使用Predicate作为查询条件，现在我们可以继续使用JDK内置的Consumer：

interface Consumer<T> {
    void accept(T t);
}

与Predicate类似，accept方法有一个输入参数，所以实现Consumer<Person>即可调用accept(Person t)方法对传入的用户信息进行操作。

所以再定义一个processPersons方法，既可以指定查询条件又可以指定动作：

public static void processPersons(
    List<Person> roster,
    Predicate<Person> tester,
    Consumer<Person> block) {
        for (Person p : roster) {
            if (tester.test(p)) {
                block.accept(p);
            }
        }
}

同样使用Lambda表达式实现打印用户信息：

processPersons(
     roster,
     p -> p.getGender() == Person.Sex.MALE
         && p.getAge() >= 18
         && p.getAge() <= 25,
     p -> p.printPerson()
);

processPersons方法有一个Predicate类型的参数和一个Consumer类型的参数，Lambda表达式可以看做是Predicate和Consumer的实例化对象，tester调用test方法过滤符合条件的用户，然后block调用acceptt方法并传入用户信息进行打印操作。

目前看到的Consumer和Predicate都是没有返回值的接口，如果说管理员需要对用户的其它信息进行校验操作，那么可以借助另一个具备返回值的函数式接口Function<T, R>来实现：

interface Function<T,R> {
    R apply(T t);
}

利用这个接口定义processPersonsWithFunction方法：

public static void processPersonsWithFunction(
    List<Person> roster,
    Predicate<Person> tester,
    Function<Person, String> mapper,
    Consumer<String> block) {
    for (Person p : roster) {
        if (tester.test(p)) {
            String data = mapper.apply(p);
            block.accept(data);
        }
    }
}

如果我们想要查看用户的Email信息，只需要用Lambda表达式进行调用：

processPersonsWithFunction(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);

processPersonsWithFunction方法中，tester过滤用户信息，然后mapper调用方法apply获得用户的Email返回信息，接着block打印了Email信息。

更加普遍的实现

processPersonsWithFunction就已经结束了么？其实不然。
processPersonsWithFunction仅仅能够处理Person类型的结果，但是这类查询并不一定只针对用户信息，其它类型的信息是不是也有同样的逻辑，那么是不是可以更加的通用呢？请看：

public static <X, Y> void processElements(
    Iterable<X> source,
    Predicate<X> tester,
    Function <X, Y> mapper,
    Consumer<Y> block) {
    for (X p : source) {
        if (tester.test(p)) {
            Y data = mapper.apply(p);
            block.accept(data);
        }
    }
}

现在已经和Person没有任何关系了，那么如何完成processPersonsWithFunction的工作呢？这样做：

processElements(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);

梳理一下processElements的过程：

1. 迭代一个可迭代对象，由于List实现了Iterator接口，所以通过迭代对象可以遍历每个对象；
2. 过滤对象，将符合条件的对象进行下一步操作；
3. 将一个对象进行转换操作，比如把用户的Email信息作为结果返回；
4. 处理一个对象，比如输出由mapper返回的结果。

聚合操作与Lambda食用更佳

可以说processElements的每个步骤都可以通过Lambda和聚合操作完成：

roster
    .stream()
    .filter(
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25)
    .map(p -> p.getEmailAddress())
    .forEach(email -> System.out.println(email));

这个看起来是不是更酷炫呢？

关于聚合操作可以参考Aggregate Operations。

参考资料

1. Learning the Java Language
2. Java 8 API