@Override
public Integer apply(String s) {
return s.length();
}
})
.filter(new Predicate() {
@Override
public boolean test(Integer l) {
return l <= 3;
}
})
.max(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});

Lambda表达式与匿名类的异同集中体现在以下三点上：

  • Lambda就是为了优化匿名内部类而生，Lambda要比匿名类简洁的多得多。
  • Lambda仅适用于函数式接口，匿名类不受限。
  • 即匿名类中的this是“匿名类对象”本身;Lambda表达式中的this是指“调用Lambda表达式的对象”。

函数接口

实际上，上面一段代码中的Function、Predicate、Comparator都是函数接口。我们知道，C语言支持函数指针，它可以把函数直接当变量来使用。

但是，Java没有函数指针这样的语法。所以它通过函数接口，将函数包裹在接口中，当作变量来使用。实际上，函数接口就是接口。不过，它也有自己特别的地方，那就是要求只包含一个未实现的方法。因为只有这样，Lambda表达式才能明确知道匹配的是哪个方法。如果有两个未实现的方法，并且接口入参、返回值都一样，那Java在翻译Lambda表达式的时候，就不知道表达式对应哪个方法了。

函数式接口也是Java interface的一种，但还需要满足：

  • 一个函数式接口只有一个抽象方法(single abstract method);
  • Object类中的public abstract method不会被视为单一的抽象方法;
  • 函数式接口可以有默认方法和静态方法;
  • 函数式接口可以用@FunctionalInterface注解进行修饰。

满足这些条件的interface，就可以被视为函数式接口。例如Java 8中的Comparator接口：

@FunctionalInterface
public interface Comparator {
/**
* single abstract method
* @since 1.8
*/
int compare(T o1, T o2);
/**
* Object类中的public abstract method
* @since 1.8
*/
boolean equals(Object obj);
/**
* 默认方法
* @since 1.8
*/
default Comparator reversed() {
return Collections.reverseOrder(this);
}
/**
* 静态方法
* @since 1.8
*/
public static <T extends Comparable<? super T>> Comparator reverseOrder() {
return Collections.reverseOrder();
}
//省略…
}

函数式接口有什么用呢?一句话，函数式接口带给我们最大的好处就是：可以使用极简的lambda表达式实例化接口。为什么这么说呢?我们或多或少使用过一些只有一个抽象方法的接口，比如Runnable、ActionListener、Comparator等等，比如我们要用Comparator实现排序算法，我们的处理方式通常无外乎两种：

  • 规规矩矩的写一个实现了Comparator接口的Java类去封装排序逻辑。若业务需要多种排序方式，那就得写多个类提供多种实现，而这些实现往往只需使用一次。
  • 另外一种聪明一些的做法无外乎就是在需要的地方搞个匿名内部类，比如：
public class Test {
public static void main(String args[]) {
List persons = new ArrayList();
Collections.sort(persons, new Comparator(){
@Override
public int compare(Person o1, Person o2) {
return Integer.compareTo(o1.getAge(), o2.getAge());
}
});
}
}

匿名内部类实现的代码量没有多到哪里去，结构也还算清晰。Comparator接口在Jdk 1.8的实现增加了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可放心的通过lambda表达式来实例化。那我们来看看使用lambda表达式来快速new一个自定义比较器所需要编写的代码：

Comparator comparator = (p1, p2) -> Integer.compareTo(p1.getAge(), p2.getAge());

-> 前面的 () 是Comparator接口中compare方法的参数列表，-> 后面则是compare方法的方法体。

下面将Java提供的Function、Predicate这两个函数接口的源码，摘抄如下：

@FunctionalInterface
public interface Function<T, R> {
R apply(T t);  // 只有这一个未实现的方法
default  Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default  Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static  Function<T, T> identity() {
return t -> t;
}
}
@FunctionalInterface
public interface Predicate {
boolean test(T t); // 只有这一个未实现的方法
default Predicate and(Predicate<? super T> other) {
Objec
ts.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate negate() {
return (t) -> !test(t);
}
default Predicate or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static  Predicate isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}

@FunctionalInterface注解使用场景

我们知道，一个接口只要满足只有一个抽象方法的条件，即可以当成函数式接口使用，有没有 @FunctionalInterface 都无所谓。但是jdk定义了这个注解肯定是有原因的，对于开发者，该注解的使用一定要三思而后续行。

如果使用了此注解，再往接口中新增抽象方法，编译器就会报错，编译不通过。换句话说，@FunctionalInterface 就是一个承诺，承诺该接口世世代代都只会存在这一个抽象方法。因此，凡是使用了这个注解的接口，开发者可放心大胆的使用Lambda来实例化。当然误用 @FunctionalInterface 带来的后果也是极其惨重的：如果哪天你把这个注解去掉，再加一个抽象方法，则所有使用Lambda实例化该接口的客户端代码将全部编译错误。
特别地，当某接口只有一个抽象方法，但没有用 @FunctionalInterface 注解修饰时，则代表别人没有承诺该接口未来不增加抽象方法，所以建议不要用Lambda来实例化，还是老老实实的用以前的方式比较稳妥。