last modified:2020/10/31
1-06-3-Lambda表达式
6.3.1 为什么引入lambda表达式
- lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。
- 将一个代码块传递到某个对象，这个代码块会在将来某个时间调用。
6.3.2 lambda表达式的语法
-
带参数变量的表达式被称为lambda表达式。
-
你已经见过Java中的一种lambda表达式形式:参数，箭头(->)以及一个表达式。
- 如果代码要完成的计算无法放在一个表达式中，就可以像写方法一样，把这些代码放在中，并包含显式的return语句。例如:
(String first,String second)-> { if (first.1ength() < second.length()) return -1; else if (first.length() > second.length()) return 1; else return 0; }- 即使lambda表达式没有参数，仍然要提供空括号，就像无参数方法一样:
() -> { for (int i = 100; i >= 0; i--) System.out.prinln(i); }- 如果可以推导出一个lambda表达式的参数类型，则可以忽略其类型。例如:
Comparator<String> comp (first,second) // Same as (String first，String second) -> first.length() - second.length();- 在这里，编译器可以推导出first和second必然是字符串，因为这个lambda表达式将赋给一个字符串比较器。(下一节会更详细地分析这个赋值。)
- 如果方法只有一个参数，而且这个参数的类型可以推导得出，那么甚至还可以省略小括号:
ActionListener listener = event -> System.out.println("The time is " + new Date()"); // Instead of (event) -> .. . or (ActionEvent event) -> ..·- 无需指定lambda表达式的返回类型。lambda表达式的返回类型总是会由上下文推导得出。例如，下面的表达式
(String first, String second)-> first.length() - second.length();- 可以在需要int类型结果的上下文中使用。
- 如果一个lambda表达式只在某些分支返回一个值，而在另外一些分支不返回值，这是不合法的。例如，(int x)->{ if(x>= 0) return1; }就不合法。
//程序显示了如何在一个比较器和一个动作监听器中使用lambda表达式
public class LambdaTest
{
public static void main(String[]args)
{
String[] planets = new String[]{ "Mercury","Venus","Earth”，
"Mars","Jupiter","Saturn","Uranus","Neptune"};
System.out.println(Arrays.toString(planets));
system.out.println("Sorted in dictionary order:");
Arrays.sort(planets);
System.out.println(Arrays.toString(planets));
system.out.println("Sorted by length:");
Arrays.sort(planets,(first,second)->first.length()-second.length());
System.out.print1n(Arrays.toString(planets));
Timer t = new Timer(1000, event->
System.out.println("The time is" +new Date());
t.start();
// keep program running until user selects "ok"
optionPane.showMessageDialog(null，"Quit program?");
System.exit(O);
}
}
6.3.3 函数式接口
-
Java中已经又很多封装代码块的接口，lambda表达式与这些接口是兼容的。
-
对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口称为函数式接口（functional interface）。
注释:你可能想知道为什么函数式接口必须有一个抽象方法。不是接口中的所有方法都是抽象的吗?实际上，接口完全有可能重新声明Object类的方法，如toString 或clone,这些声明有可能会让方法不再是抽象的。(Java API中的一些接口会重新声明Object方法来附加javadoc注释。Comparator API就是这样一个例子。）更重要的是，正如6.1.5节所述，在Java SE 8中，接口可以声明非抽象方法。
-
为了展示如何转换为函数式接口，下面考虑Arrays.sort方法。
-
它的第二个参数需要一个Comparator实例，Comparator就是只有一个方法的接口，所以可以提供一个lambda表达式:
Arrays.sort(words, (first, second)->first.length()- second.length();在底层，Arrays.sort方法会接收实现了Comparator<String>的某个类的对象。在这个对象上调用compare方法会执行这个lambda表达式的体。这些对象和类的管理完全取决于具体实现，与使用传统的内联类相比，这样可能要高效得多。最好把lambda表达式看作是一个函数，而不是一个对象，另外要接受lambda表达式可以传递到函数式接口。
-
-
实际上，在java中，对lambda表达式所能做的也只是能转换为函数式接口。
-
Java API在java.util.function包中定义了很多非常通用的函数式接口。
-
其中一个接口BiFunction<T,U,R>描述了参数类型为T和U而且返回类型为R的函数。可以把我们的字符串比较lambda表达式保存在这个类型的变量中:
BiFunction<String，String，Integer> comp = (first,second)-> first.length() - second.length();不过，这对于排序并没有帮助。没有哪个Arrays.sort方法想要接收一个BiFunction。如果你之前用过某种函数式程序设计语言，可能会发现这很奇怪。不过，对于Java程序员而言，这非常自然。类似Comparator的接口往往有一个特定的用途，而不只是提供一个有指定参数和返回类型的方法。Java SE8沿袭了这种思路。想要用lambda表达式做某些处理，还是要谨记表达式的用途，为它建立一个特定的函数式接口。
-
java.util.function包中有一个尤其有用的接口Predicate:
public interface Predicate<T> { boolean test(T t); //Additional default and static methods }ArrayList类有一个removelf方法，它的参数就是一个Predicate。这个接口专门用来传递lambda表达式。例如，下面的语句将从一个数组列表删除所有null值:
list.removeIf(e -> e == null);
-
6.3.4 方法引用
-
有时,可能已经有现成的方法可以完成你想要传递到其他代码的某个动作。
-
例如，假设你希望只要出现一个定时器事件就打印这个事件对象。当然，为此也可以调用:
Timer t = new Timer(1000,event -> System.out.println(event));但是，如果直接把printIn方法传递到Timer构造器就更好了。具体做法如下:
Timer t = new Timer(1000,System.out::println);表达式System.out::printIn是一个方法引用(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.printIn(x)。类似地，Math:pow等价于(x,y)->Math.pow(x,y)。
对于第3种情况，第1个参数会成为方法的目标。例如String::compareTolgnoreCase等同于(x，y)-> x.compareTolgnoreCase(y)。
-
-
如果有多个同名的重载方法，编译器就会尝试从上下文中找出你指的那一个方法。
- 例如，Math.max方法有两个版本，一个用于整数，另一个用于double值。选择哪一个版本取决于Math::max转换为哪个函数式接口的方法参数。类似于lambda表达式，方法引用不能独立存在，总是会转换为函数式接口的实例。
-
可以在方法引用中使用this参数。
- 例如，this::equals 等同于x -> this.equals(x)。使用super也是合法的。下面的方法表达式super::instanceMethod使用this 作为目标，会调用给定方法的超类版本。
6.3.5 构造器引用
-
构造器引用与方法引用很类似，只不过方法名为new。
-
例如，Person::new 是Person构造器的一个引用。哪个构造器呢?这取决于上下文
-
假设你有一个字符串列表。可以把它转换为一个Person对象数组，为此要在各个字符串上调用构造器，调用如下:
Arraylist<String> names= ... ; // map方法会为各个列表元素调用Person(String)构造器 Strean<Person> strean = names.stream().map(Person::new) ; List<Person> people = strean.collect(Collectors . tolist());如果有多个Person构造器，编译器会选择有一个String参数的构造器，因为它从上下文推导出这是在对一个字符串调用构造器。
-
可以用数组类型建立构造器引用。
- 例如，int[]::new 是一个构造器引用，它有一个参数：即数组的长度。这等价于lambda表达式x -> new int[x]。
-
Java有一个限制，无法构造泛型类型T的数组。
-
数组构造器引用对于克服这个限制很有用。表达式new T[n]会产生错误，因为这会改为new Object[n]。对于开发类库的人来说，这是一个问题。例如，假设我们需要一个Person对象数组。Stream接口有一个toArray方法可以返回Object数组:
0bject[] people = stream.toArray();不过，这并不让人满意。用户希望得到一个Person引用数组，而不是Object引用数组。流库利用构造器引用解决了这个问题。可以把Person[]:new传入toArray方法:
Person[] people = stream.toArray(Person[]::new);toArray方法调用这个构造器来得到一个正确类型的数组。然后填充这个数组并返回。
-
-
6.3.6 变量作用域
-
lambda 表达式有3个部分:
- 1)一个代码块;
- 2)参数;
- 3)自由变量的值，这是指非参数而且不在代码中定义的变量。
-
public static void repeatMessage(String text, int delay) { Actionlistener listener = event -> { System.out.println(text); Toolkit.getDefaultToolkit().beep(); }; new Timer(delay,listener).start(); } //来看这样一个调用: repeatMessage("Hel1o",1000); // Prints Hel1o every 1,000 milliseconds -
在我们的例子中，这个lambda表达式有1个自由变量text。表示lambda表达式的数据结构必须存储自由变量的值，在这里就是字符串"Hello"。我们说它被lambda表达式捕获
( captured)。(下面来看具体的实现细节。例如，可以把一个lambda表达式转换为包含一个方法的对象，这样自由变量的值就会复制到这个对象的实例变量中。)注释:关于代码块以及自由变量值有一个术语: 闭包( closure)。 如果有人吹噓他们的语言有闭包，现在你也可以自信地说Java也有闭包。在Java中，lambda表达式就是闭包。
-
可以看到，lambda表达式可以捕获外围作用域中变量的值。
-
在Java中，要确保所捕获的值是明确定义的，这里有一个重要的限制。
-
在lambda表达式中，只能引用值不会改变的变量。例如，下面的做法是不合法的:
public static void countDown(int start,int delay) { ActionListener listener = event ->{ start--; // Error: Can't mutate captured variable System.out.println(start); }; new Timer(delay,listener) .start(); } -
另外如果在lambda表达式中引用变量，而这个变量可能在外部改变，这也是不合法的。
例如，下面就是不合法的:public static void repeat(String text,int count) { for (int i = 1; i <= count; i++) { ActionListener listener = event -> { System.out.println(i + "; " + text); // Error: Cannot refer to changing i }; new Timer(1000 ,listener).start(); } }这里有一条规则: lambda 表达式中捕获的变量必须实际上是最终变量( effectively final)。实际上的最终变量是指，这个变量初始化之后就不会再为它赋新值。在这里，text 总是指示同一个String 对象，所以捕获这个变量是合法的。不过, i的值会改变,因此不能捕获i。
-
-
lambda表达式的体与嵌套块有相同的作用域。这里同样适用命名冲突和遮蔽的有关规则。
- 在lambda表达式中声明与一个局部变量同名的参数或局部变量是不合法的。
Path first = Paths.get("/usr/bin"); Comparator<String> comp = (first, second) -> first.length() - second.length(); // Error: Variable first already defined-
在方法中，不能有两个同名的局部变量，因此，lambda表达式中同样也不能有同名的局部变量。
-
在一个lambda表达式中使用this关键字时，是指创建这个lambda表达式的方法的this参数。例如，考虑下面的代码:
public class Application() { public void init() { ActionListener listener = event -> { //表达式this.toString()会调用Application对象的 //toString方法，而不是ActionListener实例的方法。 System.out.print1n(this. toString()); ... } ... } }在lambda表达式中，this 的使用并没有任何特殊之处。lambda 表达式的作用域嵌套在init方法中，与出现在这个方法中的其他位置一样，lambda表达式中this的含义并没有变化。
6.3.7 处理lambda表达式
-
使用lambda表达式的重点是延迟执行( deferred execution)。
-
之所以希望以后再执行代码，这有很多原因，如:
- 在一个单独的线程中运行代码;
- 多次运行代码;
- 在算法的适当位置运行代码(例如，排序中的比较操作);
- 发生某种情况时执行代码(如，点击了一个按钮，数据到达，等等);
- 只在必要时才运行代码。
-
下面来看一个简单的例子。假设你想要重复一个动作n次。将这个动作和重复次数传递
到一个repeat方法:repeat(10, () -> System.out.println("Hello, World!"));要接受这个lambda表达式，需要选择(偶尔可能需要提供)一个函数式接口。
表6-1列出了Java API中提供的最重要的函数式接口。
在这里，我们可以使用Runnable接口:
public static void repeat(int n, Runnable action) { for (int i =0; i < n; i++) action.run(); }需要说明，调用action.run()时会执行这个lambda表达式的主体。
-
现在让这个例子更复杂一些。我们希望告诉这个动作它出现在哪一次迭代中。 为此，需
要选择一个合适的函数式接口，其中要包含一个方法，这个方法有一个int参数而且返回类
型为void。处理int值的标准接口如下:public interface IntConsumer{ void accept(int value); }下面给出repeat方法的改进版本:
public static void repeat(int n, IntConsumer action){ for (int i =0; i < n; i++) action.accept(i); }可以如下调用它:
repeat(10, i -> Sysem.out.pritnln("Countdown: "+ (9 - i)));表6-2列出了基本类型int、long和double的34个可能的规范。最好使用这些特殊
化规范来减少自动装箱。出于这个原因，上一个例子中使用了IntConsumer 而不是
Consumer<Integer>。- 最好使用6-1或6-2中的接口
- 大多数标准函数式接口都提供了非抽象方法来生成或合并函数。
- 如，Predicate.isEqual（a）等同于a::equal，不过如果a为null也能正常工作。
- 如果设计你自己的接口，其中只有一个抽象方法，可以用@FunctionalInterface注
**解来标记这个接口。这样做有两个优点。- 如果你无意中增加了另一个非抽象方法，编译器会产生一个错误消息。
- 另外javadoc页里会指出你的接口是一个函数式接口。
- 并不是必须使用注解。根据定义，任何有一个抽象方法的接口都是函数式接口。不
过使用@FunctionalInterface 注解确实是一个很好的做法。
6.3.8 再谈Comparator(!!!)
-
Comparator接口包含很多方便的静态方法来创建比较器。这些方法可以用于lambda表达式或方法引用。
-
静态comparing方法取一个“键提取器”函数，它将类型T映射为一个可比较的类型
(如String)。对要比较的对象应用这个函数，然后对返回的键完成比较。例如，假设有一个Person对象数组，可以如下按名字对这些对象排序:
Arrays.sort(people，Comparator.comparing(Person:getName));与手动实现一个Comparator相比，这当然要容易得多。另外，代码也更为清晰，因为显然我们都希望按人名来进行比较。
可以把比较器与thenComparing方法串起来。例如，Arrays.sort(people,Comparator.comparing(Person::getLastName) .thenComparing(Person::getFirstNane));如果两个人的姓相同，就会使用第二个比较器。
这些方法有很多变体形式。可以为comparing和thenComparing方法提取的键指定一个比较器。例如，可以如下根据人名长度完成排序:Arrays.sort(people, Comparator.comparing(Person:getName, (s, t) -> Integer.compare(s.length(), t.length())));另外，comparing 和thenComparing方法都有变体形式，可以避免int、long或double值的装箱。要完成前一个操作，还有一种更容易的做法:
Arrays. sort(people, Comparator . comparingInt(p -> p.getName(). length));如果键函数可以返回null,可能就要用到nullFirst和nullsLast适配器。这些静态方
法会修改现有的比较器，从而在遇到null值时不会抛出异常，而是将这个值标记为小于或
大于正常值。例如，假设一个人没有中名时getMiddleName会返回一个nul,就可以使用Comparator.comparing(Person:.getMiddleName(), Comparator.nullsFirst(...))nullsFirst方法需要一个比较器， 在这里就是比较两个字符串的比较器。
naturalOrder 方法可以为任何实现了Comparable的类建立一个比较器。在这里，Comparator.<String> naturalOrder()正是我们需要的。下面是一个完整的调用，可以按可能为null 的中名进行排序。这里使用了一个静态导入java.util.Comparator.*,以便理解这个表达式。注意naturalOrder的类型可以推导得出。
Arrays.sort(people,comparing(Person::getMiddleName, nullsFirst(naturalOrder())));静态reverseOrder方法会提供自然顺序的逆序。要让比较器逆序比较，可以使用reversed实例方法。例如naturalOrder.(reversed)等同于reverseOrder()。