通俗易懂的理解Lambda表达式（二）

书接上回，我们讲了如何使用Lambda，现在就带大家来一起看几个例子，巩固下理解。
首先，我们知道了Lambda表达式可以用来生成对象，既然如此，Lambda表达式自然可以当做参数一样，传入方法！
这就是我们常说的—— 给方法传入一个执行过程.

还是上回的例子，这次我们将Lambda表达式当做参数传入方法。

public String eat(String name);

public static void main(String[] args) {

    //第二个参数直接用lambda表达式传入
    String abc = animalEat("ABC", (a) -> a.toLowerCase());
    System.out.println("输出为=============="+abc);
}

public static String animalEat(String name, IAnimal animal){
    return animal.eat(name);
}

我们可以看到，main函数执行animalEat > 方法，而animalEat方法需要一个IAnimal类型的参数，此时，根据上节的指示，我们完全可以用Lambda表达式来替代实际上的入参对象！
你可以这么理解：lambda表达式就是一个定义好接口行为的对象，只要符合方法的入参类型，完全可以替代new 出来的对象。

接下来，我们继续分享一个案例，这是大家熟悉的Stream的API，实际上，他的每个filter和map方法，都用Lambda表达式来完成的。

public static void main(String[] args) {

    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    List<Integer> collect = list.stream()
                                .filter(a -> a > 2)
                                .map(t -> t * 10)
                                .collect(Collectors.toList());
    System.out.println(JSON.toJSONString(collect));
}

我们就拿filter方法做研究，它的api是这样。

    /**
     * Returns a stream consisting of the elements of this stream that match
     * the given predicate.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                  <a href="package-summary.html#Statelessness">stateless</a>
     *                  predicate to apply to each element to determine if it
     *                  should be included
     * @return the new stream
     */
    Stream<T> filter(Predicate<? super T> predicate);

很明显，这里的入参是一个Predicate接口，那我们继续深入。

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

​我们会发现，Predicate接口也有且仅有一个抽象方法！那太好了，我们完全可以用Lambda表达式来实现。
我们可以看到，他的test方法，有一个T类型的入参，boolean类型的出参。
那我们先用Lambda实现一个Predicate接口。

public class Test2 {

    public static void main(String[] args) {
        //这个定义泛型是为了适配下面Integer类型的集合
        Predicate<Integer> predicate = (a)-> a>3;  //用lambda表达式定义好对象

        List<Integer> list = Arrays.asList(1,2,3,4,5,6);

        List<Integer> collect = list.stream()
            .filter(predicate)      //将对象传入参数
            .map(t -> t * 10)
            .collect(Collectors.toList());

    }
    //返回  10,20,30,40,50,60
}

然后，我们为了图简便，就可以直接将Lambda表达式，写入Stream的调用链中，就像这样。

public class Test2 {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1,2,3,4,5,6);

        List<Integer> collect = list.stream()
            .filter(a-> a>3)      //将对象传入参数
            .collect(Collectors.toList());

    }

    //返回  10,20,30,40,50,60
}