Java 8 Lambda（语言篇——lambda，方法引用，目标类型和默认方法）

最新推荐文章于 2024-09-11 20:25:27 发布

jw598527338

最新推荐文章于 2024-09-11 20:25:27 发布

阅读量2.3k

点赞数 1

本文链接：https://blog.csdn.net/jw598527338/article/details/80973653

版权

参考资料：

https://www.cnblogs.com/figure9/archive/2014/10/24/4048421.html

关键问题

Java 8中的lambda为什么要设计成这样？（为什么要一个lambda对应一个接口？而不是Structural Typing？）
lambda和匿名类型的关系是什么？lambda是匿名对象的语法糖吗？
Java 8是如何对lambda进行类型推导的？它的类型推导做到了什么程度？
Java 8为什么要引入默认方法？
Java编译器如何处理lambda？

主要内容

lambda表达式（又被成为“闭包”或“匿名方法”）
方法引用和构造方法引用
扩展的目标类型和类型推导
接口中的默认方法和静态方法

1 、背景

Java API中定义了一个接口（一般被称为回调接口），用户通过提供这个接口的实例来传入指定行为，例如：

public interface ActionListener {

void actionPerformed(ActionEvent e);

}

这里并不需要专门定义一个类来实现ActionListener接口，因为它只会在调用处被使用一次。用户一般会使用匿名类型把行为内联（inline）：

button.addActionListener(new ActionListener) {

public void actionPerformed(ActionEvent e) {

ui.dazzle(e.getModifiers());

}

随着回调模式和函数式编程风格的日益流行，我们需要在Java中提供一种尽可能轻量级的将代码封装为数据（Model code as data）的方法。匿名内部类并不是一个好的选择，因为：

语法过于冗余
匿名类中的this和变量名容易使人产生误解
类型载入和实例创建语义不够灵活
无法捕获非final的局部变量
无法对控制流进行抽象

上面的多数问题均在Java SE 8中得以解决：

通过提供更简洁的语法和局部作用域规则，Java SE 8彻底解决了问题1和问题2
通过提供更加灵活而且便于优化的表达式语义，Java SE 8绕开了问题3
通过允许编译器推断变量的“常量性”（finality），Java SE 8减轻了问题4带来的困扰

2 函数式接口（SAM类型）

ActionListener、Runnable、Comparator等
编译器根据接口格式自行判断；使用@FunctionalInterface注解判断；

除此之外，Java SE 8中增加了一个新的包：java.util.function，它里面包含了常用的函数式接口，例如：

Predicate<T>——接收T对象并返回boolean
Consumer<T>——接收T对象，不返回值
Function<T, R>——接收T对象，返回R对象
Supplier<T>——提供T对象（例如工厂），不接收值
UnaryOperator<T>——接收T对象，返回T对象
BinaryOperator<T>——接收两个T对象，返回T对象

3 lambda表达式

lambada表达式其实就是一个函数，广泛的被作为一个回调函数使用

解决‘高度问题’：

// Java 8之前：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Before Java8, too much code for too little to do");
}
}).start();

1
2
//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();
几个lambda表达式：

(int x, int y) -> x + y
() -> 42
(String s) -> { System.out.println(s); }
- 表达式由参数列表、箭头符号和函数体构成；函数体既可以是一个表达式，也可以是一个语句块
  FileFilter java = (File f) -> f.getName().endsWith("*.java");
  
  new Thread(() -> {
  
  connectToService();
  
  sendNotification();
  
  }).start();

4 目标类型

编译器负责推导lambda表达式的类型。它利用lambda表达式所在上下文所期待的类型进行推导，这个被期待的类型被称为目标类型。

Callable<String> c = () -> "done";
Comparator<String> c = (s1, s2) -> s1.compareToIgnoreCase(s2);

也因此参数列表也不需要再体现参数类型，同时也为了不将‘高度问题’变成‘宽度问题’；
检查是否符合目标类型
- T是一个函数式接口
- lambda表达式的参数和T的方法参数在数量和类型上一一对应
- lambda表达式的返回值和T的方法返回值相兼容（Compatible）
- lambda表达式内所抛出的异常和T的方法throws类型相兼容
目标类型上下文

List<Person> ps = ... Stream<String> names = ps.stream().map(p -> p.getName());

在上面的代码中，ps的类型是List<Person>，所以ps.stream()的返回类型是Stream<Person>。
map()方法接收一个类型为Function<T, R>的函数式接口，这里T的类型即是Stream元素的类型，也就是Person，而R的类型未知。
由于在重载解析之后lambda表达式的目标类型仍然未知，我们就需要推导R的类型。
通过对lambda表达式函数体进行类型检查，我们发现函数体返回String，因此R的类型是String，因而map()返回Stream<String>。

转型表达式（Cast expression）可以显式提供lambda表达式的类型，这个特性在无法确认目标类型时非常有用：

Object o = (Runnable) () -> { System.out.println("hi"); };

5 关于变量的问题

内部类中通过继承得到的成员（包括来自Object的方法）可能会把外部类的成员掩盖，lambda表达式函数体里面的变量和它外部环境的变量具有相同的语义。

java 7中的变量必须被声明为final，才能在内部类中使用；java 8 放宽限制，有效只读类型的变量也允许；简而言之，lambda表达式对值封闭，对变量开放。

int sum = 0; list.forEach(e -> { sum += e.size(); }); // Illegal, close over values

List<Integer> aList = new List<>(); list.forEach(e -> { aList.add(e); }); // Legal, open over variables

对于值的修改，可以使用reduce方法。

6 方法引用

方法引用和lambda表达式拥有相同的特性

 
          Person[] people = ... 
            
          //lambda表达式 
          Comparator<Person> byName = Comparator.comparing(p -> p.getName()); 
          //方法引用 
          Comparator<Person> byName = Comparator.comparing(Person::getName); 
         

这里的Person::getName可以被看作为lambda表达式的简写形式。尽管方法引用不一定会把语法变的更紧凑，但它拥有更明确的语义。

函数式接口的方法参数对应于隐式方法调用时的参数：

 
          Consumer<Integer> b1 = System::exit;    // void exit(int status) 
            
          Consumer<String[]> b2 = Arrays:sort;    // void sort(Object[] a) 
            
          Function<String, String> upperfier = String::toUpperCase; // String toUpperCase(String str) 
          Predicate<String> isKnown = knownNames::contains; // boolean contains(String str)

方法引用有很多种，它们的语法如下，静态方法和实例方法的引用并无不同，编译器会自己判断调用的方法：

静态方法引用：ClassName::methodName
实例上的实例方法引用：instanceReference::methodName
超类上的实例方法引用：super::methodName
类型上的实例方法引用：ClassName::methodName
构造方法引用：Class::new
数组构造方法引用：TypeName[]::new

7 默认方法和静态接口方法

Java SE 7时代为一个已有的类库增加功能是非常困难的
默认方法拥有其默认实现，实现接口的类型通过继承得到该默认实现（如果类型没有覆盖该默认实现）
可以向函数式接口中添加默认方法，而不用担心函数式接口的单抽象方法限制

interface Iterator<E> {

boolean hasNext();

E next();

void remove();

default void forEachRemaining(Consumer<? super E> action) {

Objects.requireNonNull(action);

while (hasNext())

action.accept(next());

}

当接口继承其它接口时，我们既可以为它所继承而来的抽象方法提供一个默认实现，也可以为它继承而来的默认方法提供一个新的实现，还可以把它继承而来的默认方法重新抽象化。
Java SE 8允许在接口中定义静态方法。这使得我们可以从接口直接调用和它相关的辅助方法（Helper method），
而不是从其它的类中调用（之前这样的类往往以对应接口的复数命名，例如Collections）。

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<T, U> keyExtractor) {
return (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

8 应用示例

java 8之前的写法

List<Person> people = ...
Collections.sort(people, new Comparator<Person>() {
public int compare(Person x, Person y) {
return x.getLastName().compareTo(y.getLastName());
}
})