JDK8 于2014年发布至今，已有6个年头。其中几个重要的特性，lambda表达式，函数式接口，方法引用，默认方法等，至今未完全普及。在回到家乡邯郸这个三线小城市后，竟然有同事问我，有没有简单的统计List数据的方法，颇让我惊讶。虽然我认为一个对公司有贡献的程序员，首先应该熟悉业务。但是我也担心，技术上落后太多，也会拖累项目的性能。因此，本着服务家乡的想法，梳理一下Java程序员基本的知识点。与互联网项目不同，我更加重视基础知识。对于微服务框架，我认为绝大多数应用，是用不到的。如果为了使用而使用，只会增加团队不必要的负担。闲话不多说，我们开始介绍Lambda，同时，会介绍函数式接口。

引言

Lambda表达式，也可以称作闭包。它是推动Jdk8发布的最重要的特性。在此之前，jdk是不允许将函数作为参数进行传递的，即不支持函数式编程。这使其在很多地方，代码过于啰嗦，如同老太太的叨叨。因此，在Jdk8引入Lambda后，代码变得更加简洁，更加清晰了。

Lambda语法

完整的Lambda表达式包含三部分组成：参数列表，箭头，声明语句。

（Type1 param1, Type2 param2, ..., TypeN paramN）-> {声明1; 声明2; ...... return mentmentM;}

以下是Lambda表达是的重要说明：

1，参数可选类型声明：不需要指明param1，param2的具体类型，编译器可以自动识别。于是，上面可以简化为：

（param1, param2, ..., paramN）-> {指令1; 指令2; ......}

2，参数可选圆括号：当参数仅有1个的时候，圆括号可以省略。于是，上面可以继续简化为：

param-> {指令1; 指令2; ......}

3，函数体可选大括号：当函数体中仅包含一个指令的时候，大括号可以省略。

param-> 指令1;

具体表达式示例

// 1.不需要的参数，返回变量5 
() -> 5

// 2.接收一个参数（数字类型），返回其2倍的值
x -> 2 * x

// 3.接受2个参数（数字），并返回他们的差值
(x，y) -> x-y

// 4.接收2个int型整数，返回他们的和
(int x, int y) -> x + y

// 5.接受一个字符串对象，并在控制台打印，不返回任何值（看起来像是返回void）
(String s)-> System.out.print(s)

函数式接口

要想使用Lambda，必然需要一个函数式接口。那么，什么是函数式接口呢？函数式接口，Functional Interface，必须有且仅有一个抽象方法的接口，对默认方法的个数没有限制（Jdk8 允许在接口中有默认实现），同时函数式接口用@FunctionalInterface来标注。函数式接口可以友好的支持Lambda。

Jdk8 之前符合函数式接口条件的接口有：

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

Jdk8 新增的函数接口一般都存储在java.util.function中，其中有很多类，这里不一一赘述。感兴趣的同学，可以在这个package中自学一下。接下来，我们举两个例子，来说明函数式接口与Lambda的用法。

public class LambdaDemo {

    public static void main(String[] args) {
        runDemo();
    }

    public static void runDemo() {
        //传统定义
        Runnable runnableJdk7 = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        };
        runnableJdk7.run();

        //Lambda 形式
        Runnable runnableJdk8 = () -> System.out.println(Thread.currentThread());
        runnableJdk8.run();
    }

}

上述代码，以定义一个线程为例，展示了Jdk8以前以及Jdk8的做法。那么，Lambda究竟做了什么呢？很明显，简化了接口抽象方法的实现，我们用Lambda实现了Runnable的 run方法，并创建了一个对象runnableJdk8。这就是函数式接口必须有且只能有一个抽象方法的原因。因为创建的时候，等号右面必须有，且只能有一个Lambda表达式，这个Lambda表达式，就是用来实现这个函数式接口唯一的抽象方法。

我们再举一个例子，假设有一张学生成绩表，筛选成绩大于80的。该怎么写呢？

public static void score() {

        List<Student> listJdk7 = new ArrayList<>(
                Arrays.asList(
                        new Student(1, "张三", 41),
                        new Student(2, "王二", 92),
                        new Student(3, "李四", 52),
                        new Student(4, "王五", 81),
                        new Student(5, "赵六", 67)
                )
        );

        Iterator<Student> listIt = listJdk7.iterator();
        while (listIt.hasNext()) {
            Student next = listIt.next();
            if (next.getScore().intValue() < 80) {
                listIt.remove();
            }
        }
        System.out.println(JSON.toJSONString(listJdk7, SerializerFeature.PrettyFormat));
                
            //以下是Jdk8 Lambda 结合 函数式接口
        List<Student> listJdk8 = new ArrayList<>(
                Arrays.asList(
                        new Student(1, "张三", 41),
                        new Student(2, "王二", 92),
                        new Student(3, "李四", 52),
                        new Student(4, "王五", 81),
                        new Student(5, "赵六", 67)
                )
        );
        List<Student> collect = listJdk8.stream().filter(x -> x.getScore() > 80).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(collect, SerializerFeature.PrettyFormat));
    }

Jdk7这里不再解释，这里解释一下Jdk8的实现。Jdk8调用了Stream的实现类java.util.stream.ReferencePipeline<P_IN, P_OUT>的filter方法，具体实现如下。

    @Override
    public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
        Objects.requireNonNull(predicate);
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                     StreamOpFlag.NOT_SIZED) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
                return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void begin(long size) {
                        downstream.begin(-1);
                    }

                    @Override
                    public void accept(P_OUT u) {
                        if (predicate.test(u))
                            downstream.accept(u);
                    }
                };
            }
        };
    }

从实现中，我们可以看到，这个方法，传入一个java.util.function.Predicate的接口函数，并且调用了其抽象方法test(T t)。该接口的内容大致如下，其中抽象方法test，接受一个输入对象，返回ture或者false。额，我觉得这有点废话，毕竟代码是这么写的。(#^.#)

@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);
        
        ...
}

我们刚才的写法是

x -> x.getScore() > 80

x 代表我们要操作的对象，也就是test方法的入参t。而x.getScore()>80则是test方法的具体实现。这个实现会返回boolean值。这样是不是好理解了。

总结

借助函数式接口与接口默认方法，可以使代码变得更简洁，更快速。

那么，要来一杯咖啡吗？

附录：Jdk8 自带的函数式接口