「lambda表达式」函数式接口、方法引用与构造器引用-lambda表达式引用传递

函数式接口

Java 中已经有很多封装代码块的接口，如 ActionListener 或 Comparator。 lambda 表达式与这些接口是兼容的。对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个 lambda 表达式。这种接口称为函数式接口（ functional interface ) 。

为什么函数式接口必须有一个抽象方法。不是接口中的所有方法都是抽象的吗？实际上，接口完全有可能重新声明 Object 类的方法，如 toString 或 clone, 这些声明有可能会让方法不再是抽象的。（ Java API 中的一些接口会重新声明 Object 方法来附加 javadoc 注释。Comparator API 就是这样一个例子。）更重要的是，正如 6.1.5 节所述，在 JavaSE 8 中，接口可以声明非抽象方法。

最好把 lambda 表达式看作是一个函数，而不是一个对象，另外要接受 lambda 表达式可以传递到函数式接口。 lambda 表达式可以转换为接口，这一点让 lambda 表达式很有吸引力。具体的语法很简短。

实际上，在 Java 中，对 lambda 表达式所能做的也只是能转换为函数式接口。在其他支持函数字面量的程序设计语言中，可以声明函数类型（如（String, String) -> int) 、声明这些类型的变量，还可以使用变量保存函数表达式。不过，Java 设计者还是决定保持我们熟悉的接口概念，没有为 Java 语言增加函数类型。

甚至不能把 lambda 表达式赋值给类型为 Object 的变量，Object 不是一个函数式接口。

Java API 在 java.util.function 包中定义了很多非常通用的函数式接口。其中一个接口 BiFunction<T,U,R> 描述了参数类型为 T 和 U 而且返回类型为 R 的函数。可以把我们的字符串比较 lambda 表达式保存在这个类型的变量中：

BiFunction<String,String,Integer> comp = (first,second) -> first.length() - second.length();

类似 Comparator 的接口往往有一个特定的用途，而不只是提供一个有指定参数和返回类型的方法。Java SE 8 沿袭了这种思路。想要用 lambda 表达式做某些处理，还是要谨记表达式的用途，为它建立一个特定的函数式接口。

java.util.function 包中有一个尤其有用的接口 Predicate:

public interface Predicate<T>
{
boolean test(T t);
// Additional default and static methods
}

ArrayList 类有一个 removelf 方法，它的参数就是一个 Predicate 。这个接口专门用来传递 lambda 表达式。例如，下面的语句将从一个数组列表删除所有 null 值： list.removelf(e -> e == null);

方法引用

有时，可能已经有现成的方法可以完成你想要传递到其他代码的某个动作。例如，假设你希望只要出现一个定时器事件就打印这个事件对象。当然，为此也可以调用:

Timer t = new Timer(1000, event -> System.out .println(event)):

但是，如果直接把 println 方法传递到 Timer 构造器就更好了。具体做法如下：

Timer t = new Timer(1000, System.out::println);

表达式 System.out::println 是一个方法引用（ method reference ), 它等价于 lambda 表达式

x -> System.out.println(x) 。

再来看一个例子，假设你想对字符串排序，而不考虑字母的大小写。可以传递以下方法表达式：

Arrays.sort(strings , String::compareToIgnoreCase)

从这些例子可以看出，要用 :: 操作符分隔方法名与对象或类名。主要有 3 种情况：

object::instanceMethod
Class::staticMethod
Class::instanceMethod

在前 2 种情况中，方法引用等价于提供方法参数的 lambda 表达式。前面已经提到的，System.out::println等价于 x -> System.out.println(x) 。类似地，Math::pow 等价于(x , y) -> Math.pow(x , y)。

对于第 3 种情况，第 1 个参数会成为方法的目标。例如，
String::compareToIgnoreCase 等同于 (x, y) -> x.compareToIgnoreCase(y) 。

如果有多个同名的重栽方法，编译器就会尝试从上下文中找出你指的那一个方法。例如， Math.max 方法有两个版本，一个用于整数，另一个用于 double 值。选择哪一个版本取决于 Math::max 转换为哪个函数式接口的方法参数。类似于 lambda 表达式，方法引用不能独立存在，总是会转换为函数式接口的实例。

可以在方法引用中使用 this 参数。例如，this::equals 等同于 x -> this.equals(x) 。使用 super 也是合法的。下面的方法表达式：

super::instanceMethod

使用 this 作为目标，会调用给定方法的超类版本。

class Greeter{
  public void greet(){
  System.out.println("Hello, world!");
  }
}
class TimedGreeter extends Greeter{
  public void greet(){
      Timer t = new Timer(1000, super::greet);
    t.start();
  }
}

TimedGreeter.greet 方法开始执行时，会构造一个 Timer, 它会在每次定时器滴答时执行 super::greet 方法。这个方法会调用超类的 greet 方法。

构造器引用

构造器引用与方法引用很类似，只不过方法名为 new 。例如，Person::new 是 Person 构造器的一个引用。哪一个构造器呢？这取决于上下文。假设你有一个字符串列表。可以把它转换为一个 Person 对象数组，为此要在各个字符串上调用构造器，调用如下：

ArrayList names = . . .; 
Stream stream = names.stream().map(Person::new); 
List people = stream.collect(Collectors.toList());

map 方法会为各个列表元素调用 Person(String) 构造器。如果有多个 Person 构造器，编译器会选择有一个 String 参数的构造器，因为它从上下文推导出这是在对一个字符串调用构造器。

可以用数组类型建立构造器引用。例如， int[]::new 是一个构造器引用，它有一个参数：即数组的长度。这等价于 lambda 表达式 x -> new int[x] ;

Java 有一个限制，无法构造泛型类型 T 的数组。数组构造器引用对于克服这个限制很有用。表达式 new T[n] 会产生错误，因为这会改为 new Object[n] 。对于开发类库的人来说，这是一个问题。例如，假设我们需要一个 Person 对象数组。Stream 接口有一个 toArray 方法可以返回 Object 数组：

Object[] people = stream.toArray();

不过，这并不让人满意。用户希望得到一个 Person 引用数组，而不是 Object 引用数组。流库利用构造器引用解决了这个问题。可以把 Person[]::new 传入 toArray 方法：

Person[] people = stream.toArray(Person[]::new);

toArray 方法调用这个构造器来得到一个正确类型的数组。然后填充这个数组并返回。