In this section, we first discuss Lambda expressions. What is it? what's the function?
Lambda expression is a new syntax introduced in Java 8. is a compact way to transfer code. Its name comes from the lambda calculus in academia. We will not detail it. discussed.
To understand Lambda expressions, let’s first review interfaces, anonymous inner classes and code passing.
Transmitting code through interfaces
We introduced interfaces and interface-oriented programming in Section 19, programming for interfaces rather than specific types. It can reduce program coupling, improve flexibility, and improve reusability. Interfaces are often used to transfer code. For example, in 59 Section, we introduced the following methods of File:
public String[] list(FilenameFilter filter)public File[] listFiles(FilenameFilter filter)
What list and listFiles need is not the FilenameFilter object, but the following method it contains:
boolean accept(File dir, String name);
In other words, list and listFiles hope to accept a method code as a parameter , but there is no way to directly pass the method code itself, only an interface can be passed.
For another example, we introduced some algorithms of Collections in Section 53. Many methods accept a parameter Comparator, such as:
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)public static <T> void sort(List<T> list, Comparator<? super T> c)
What they need is not the Comparator object, but the following methods it contains:
int compare(T o1, T o2);
However, there is no way to pass the method directly, only an interface .
We introduced the asynchronous task execution service ExecutorService in Section 77. The methods for submitting tasks are:
<T> Future<T> submit(Callable<T> task);<T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task);
Callable and Runnable interfaces are also used to transfer task codes.
To pass behavioral code through an interface, you must pass an instance object that implements the interface. In the previous chapters, the most concise way is to use anonymous inner classes, such as:
//列出当前目录下的所有后缀为.txt的文件File f = new File(".");
File[] files = f.listFiles(new FilenameFilter(){
@Overridepublic boolean accept(File dir, String name) {if(name.endsWith(".txt")){return true;
}return false;
}
});Sort files by file name, the code is:
Arrays.sort(files, new Comparator<File>() {
@Overridepublic int compare(File f1, File f2) {return f1.getName().compareTo(f2.getName());
}
});Submit the simplest task, the code is:
ExecutorService executor = Executors.newFixedThreadPool(100);
executor.submit(new Runnable() {
@Overridepublic void run() {
System.out.println("hello world");
}
});Lambda expression
Syntax
Java 8 provides a new compact The syntax for passing code - Lambda expressions. For the example of the file listed earlier, the code can be changed to:
File f = new File(".");
File[] files = f.listFiles((File dir, String name) -> {if (name.endsWith(".txt")) {return true;
}return false;
});It can be seen that compared with anonymous inner classes, passing code becomes more intuitive, and there is no longer an interface to implement. The template code no longer declares the method, nor does it have a name, but directly gives the implementation code of the method. The Lambda expression is divided into two parts by ->. The first part is the parameters of the method, and the following {} is the code of the method.
The above code can be simplified to:
File[] files = f.listFiles((File dir, String name) -> {return name.endsWith(".txt");
});When the main code has only one statement, the brackets and return statement can also be omitted, and the above code can be changed to:
File[] files = f.listFiles((File dir, String name) -> name.endsWith(".txt"));Note that when there are no parentheses, the main code is an expression, and the value of this expression is the return value of the function. There cannot be a semicolon; or a return statement at the end.
The parameter type declaration of the method can also be omitted. The above code can be further simplified to:
File[] files = f.listFiles((dir, name) -> name.endsWith(".txt"));The reason why the parameter type of the method can be omitted is because Java can automatically It is inferred that it knows that the parameter type accepted by listFiles is FilenameFilter. This interface has only one method accept, and the two parameter types of this method are File and String.
With this simplification, is the code much simpler and clearer?
The sorting code can be written using Lambda expression as:
Arrays.sort(files, (f1, f2) -> f1.getName().compareTo(f2.getName()));
Submit the task The code can be written using Lambda expression as:
executor.submit(()->System.out.println("hello"));If the parameter part is empty, write it as ().
When there is only one parameter, the parentheses in the parameter part can be omitted. For example, File also has the following methods:
public File[] listFiles(FileFilter filter)
FileFilter is defined as:
public interface FileFilter {boolean accept(File pathname);
}Use FileFilter to rewrite the above example of listing files. The code can be:
File[] files = f.listFiles(path -> path.getName().endsWith(".txt"));Variable reference
Similar to anonymous inner classes, Lambda expressions can also access variables defined outside the main code, but for local variables, it can only access final type variables. The difference from anonymous inner classes is that it does not require variables to be declared as final, but the variable cannot actually be reassigned. For example:
String msg = "hello world"; executor.submit(()->System.out.println(msg));
You can access the local variable msg, but msg cannot be reassigned. If you write like this:
String msg = "hello world"; msg = "good morning"; executor.submit(()->System.out.println(msg));
Java编译器会提示错误。
这个原因与匿名内部类是一样的，Java会将msg的值作为参数传递给Lambda表达式，为Lambda表达式建立一个副本，它的代码访问的是这个副本，而不是外部声明的msg变量。如果允许msg被修改，则程序员可能会误以为Lambda表达式会读到修改后的值，引起更多的混淆。
为什么非要建副本，直接访问外部的msg变量不行吗？不行，因为msg定义在栈中，当Lambda表达式被执行的时候，msg可能早已被释放了。如果希望能够修改值，可以将变量定义为实例变量，或者，将变量定义为数组，比如：
String[] msg = new String[]{"hello world"};
msg[0] = "good morning";
executor.submit(()->System.out.println(msg[0]));与匿名内部类比较
从以上内容可以看出，Lambda表达式与匿名内部类很像，主要就是简化了语法，那它是不是语法糖，内部实现其实就是内部类呢？答案是否定的，Java会为每个匿名内部类生成一个类，但Lambda表达式不会，Lambda表达式通常比较短，为每个表达式生成一个类会生成大量的类，性能会受到影响。
Java利用了Java 7引入的为支持动态类型语言引入的invokedynamic指令、方法句柄(method handle)等，具体实现比较复杂，我们就不探讨了，感兴趣可以参看~briangoetz/lambda/lambda-translation.html，我们需要知道的是，Java的实现是非常高效的，不用担心生成太多类的问题。
Lambda表达式不是匿名内部类，那它的类型到底是什么呢？是函数式接口。
函数式接口
Java 8引入了函数式接口的概念，函数式接口也是接口，但只能有一个抽象方法，前面提及的接口都只有一个抽象方法，都是函数式接口。之所以强调是"抽象"方法，是因为Java 8中还允许定义其他方法，我们待会会谈到。Lambda表达式可以赋值给函数式接口，比如：
FileFilter filter = path -> path.getName().endsWith(".txt");
FilenameFilter fileNameFilter = (dir, name) -> name.endsWith(".txt");
Comparator<File> comparator = (f1, f2) -> f1.getName().compareTo(f2.getName());
Runnable task = () -> System.out.println("hello world");如果看这些接口的定义，会发现它们都有一个注解@FunctionalInterface，比如：
@FunctionalInterfacepublic interface Runnable {public abstract void run();
}@FunctionalInterface用于清晰地告知使用者，这是一个函数式接口，不过，这个注解不是必需的，不加，只要只有一个抽象方法，也是函数式接口。但如果加了，而又定义了超过一个抽象方法，Java编译器会报错，这类似于我们在85节介绍的Override注解。
预定义的函数式接口
接口列表
Java 8定义了大量的预定义函数式接口，用于常见类型的代码传递，这些函数定义在包java.util.function下，主要的有：
对于基本类型boolean, int, long和double，为避免装箱/拆箱，Java 8提供了一些专门的函数，比如，int相关的主要函数有：
这些函数有什么用呢？它们被大量使用于Java 8的函数式数据处理Stream相关的类中，关于Stream，我们下节介绍。
即使不使用Stream，也可以在自己的代码中直接使用这些预定义的函数，我们看一些简单的示例。
Predicate示例
为便于举例，我们先定义一个简单的学生类Student，有name和score两个属性，如下所示，我们省略了getter/setter方法。
static class Student {
String name;double score; public Student(String name, double score) {this.name = name;this.score = score;
}
}有一个学生列表:
List<Student> students = Arrays.asList(new Student[] {new Student("zhangsan", 89d),new Student("lisi", 89d),new Student("wangwu", 98d) });在日常开发中，列表处理的一个常见需求是过滤，列表的类型经常不一样，过滤的条件也经常变化，但主体逻辑都是类似的，可以借助Predicate写一个通用的方法，如下所示：
public static <E> List<E> filter(List<E> list, Predicate<E> pred) {
List<E> retList = new ArrayList<>();for (E e : list) {if (pred.test(e)) {
retList.add(e);
}
}return retList;
}这个方法可以这么用：
// 过滤90分以上的students = filter(students, t -> t.getScore() > 90);
Function示例
列表处理的另一个常见需求是转换，比如，给定一个学生列表，需要返回名称列表，或者将名称转换为大写返回，可以借助Function写一个通用的方法，如下所示：
public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
List<R> retList = new ArrayList<>(list.size());for (T e : list) {
retList.add(mapper.apply(e));
}return retList;
}根据学生列表返回名称列表的代码可以为：
List<String> names = map(students, t -> t.getName());
将学生名称转换为大写的代码可以为：
students = map(students, t -> new Student(t.getName().toUpperCase(), t.getScore()));
Consumer示例
在上面转换学生名称为大写的例子中，我们为每个学生创建了一个新的对象，另一种常见的情况是直接修改原对象，具体怎么修改通过代码传递，这时，可以用Consumer写一个通用的方法，比如：
public static <E> void foreach(List<E> list, Consumer<E> consumer) {for (E e : list) {
consumer.accept(e);
}
}上面转换为大写的例子可以改为：
foreach(students, t -> t.setName(t.getName().toUpperCase()));
以上这些示例主要用于演示函数式接口的基本概念，实际中应该使用下节介绍的流API。
方法引用
基本用法
Lambda表达式经常就是调用对象的某个方法，比如：
List<String> names = map(students, t -> t.getName());
这时，它可以进一步简化，如下所示：
List<String> names = map(students, Student::getName);
Student::getName这种写法，是Java 8引入的一种新语法，称之为方法引用，它是Lambda表达式的一种简写方法，由::分隔为两部分，前面是类名或变量名，后面是方法名。方法可以是实例方法，也可以是静态方法，但含义不同。
我们看一些例子，还是以Student为例，先增加一个静态方法：
public static String getCollegeName(){return "Laoma School";
}静态方法
对于静态方法，如下语句：
Supplier<String> s = Student::getCollegeName;
等价于：
Supplier<String> s = () -> Student.getCollegeName();
它们的参数都是空，返回类型为String。
实例方法
而对于实例方法，它第一个参数就是该类型的实例，比如，如下语句：
Function<Student, String> f = Student::getName;
等价于：
Function<Student, String> f = (Student t) -> t.getName();
对于Student::setName，它是一个BiConsumer，即：
BiConsumer<Student, String> c = Student::setName;
等价于：
BiConsumer<Student, String> c = (t, name) -> t.setName(name);
通过变量引用方法
如果方法引用的第一部分是变量名，则相当于调用那个对象的方法，比如：
Student t = new Student("张三", 89d);
Supplier<String> s = t::getName;等价于：
Supplier<String> s = () -> t.getName();
而：
Consumer<String> consumer = t::setName;
等价于：
Consumer<String> consumer = (name) -> t.setName(name);
构造方法
对于构造方法，方法引用的语法是<类名>::new，如Student::new，如下语句：
BiFunction<String, Double, Student> s = (name, score) -> new Student(name, score);
等价于：
BiFunction<String, Double, Student> s = Student::new;
函数的复合
在前面的例子中，函数式接口都用作方法的参数，其他部分通过Lambda表达式传递具体代码给它，函数式接口和Lambda表达式还可用作方法的返回值，传递代码回调用者，将这两种用法结合起来，可以构造复合的函数，使程序简洁易读。
下面我们会看一些例子，在介绍例子之前，我们先需要介绍Java 8对接口的增强。
接口的静态方法和默认方法
在Java 8之前，接口中的方法都是抽象方法，都没有实现体，Java 8允许在接口中定义两类新方法：静态方法和默认方法，它们有实现体，比如：
public interface IDemo {void hello();public static void test() {
System.out.println("hello");
}default void hi() {
System.out.println("hi");
}
}test()就是一个静态方法，可以通过IDemo.test()调用。在接口不能定义静态方法之前，相关的静态方法往往定义在单独的类中，比如，Collection接口有一个对应的单独的类Collections，在Java 8中，就可以直接写在接口中了，比如Comparator接口就定义了多个静态方法。
hi()是一个默认方法，由关键字default标识，默认方法与抽象方法都是接口的方法，不同在于，它有默认的实现，实现类可以改变它的实现，也可以不改变。引入默认方法主要是函数式数据处理的需求，是为了便于给接口增加功能。
在没有默认方法之前，Java是很难给接口增加功能的，比如List接口，因为有太多非Java JDK控制的代码实现了该接口，如果给接口增加一个方法，则那些接口的实现就无法在新版Java 上运行，必须改写代码，实现新的方法，这显然是无法接受的。函数式数据处理需要给一些接口增加一些新的方法，所以就有了默认方法的概念，接口增加了新方法，而接口现有的实现类也不需要必须实现它。
看一些例子，List接口增加了sort方法，其定义为：
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();for (Object e : a) {
i.next();
i.set((E) e);
}
}Collection接口增加了stream方法，其定义为：
default Stream<E> stream() {return StreamSupport.stream(spliterator(), false);
}需要说明的是，即使能定义方法体了，接口与抽象类还是不一样的，接口中不能定义实例变量，而抽象类可以。
了解了静态方法和默认方法，我们看一些利用它们实现复合函数的例子。
Comparator中的复合方法
Comparator接口定义了如下静态方法：
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable)
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}这个方法是什么意思呢？它用于构建一个Comparator，比如，在前面的例子中，对文件按照文件名排序的代码为：
Arrays.sort(files, (f1, f2) -> f1.getName().compareTo(f2.getName()));
使用comparing方法，代码可以简化为：
Arrays.sort(files, Comparator.comparing(File::getName));
这样，代码的可读性是不是大大增强了？comparing方法为什么能达到这个效果呢？它构建并返回了一个符合Comparator接口的Lambda表达式，这个Comparator接受的参数类型是File，它使用了传递过来的函数代码keyExtractor将File转换为String进行比较。像comparing这样使用复合方式构建并传递代码并不容易阅读和理解，但调用者很方便，也很容易理解。
Comparator还有很多默认方法，我们看两个：
default Comparator<T> reversed() {return Collections.reverseOrder(this);
}default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);return (Comparator<T> & Serializable) (c1, c2) -> {int res = compare(c1, c2);return (res != 0) ? res : other.compare(c1, c2);
};
}reversed返回一个新的Comparator，按原排序逆序排。thenComparing也是一个返回一个新的Comparator，在原排序认为两个元素排序相同的时候，使用提供的other Comparator进行比较。
看一个使用的例子，将学生列表按照分数倒序排(高分在前)，分数一样的，按照名字进行排序，代码如下所示：
students.sort(Comparator.comparing(Student::getScore) .reversed() .thenComparing(Student::getName));
这样，代码是不是很容易读？
java.util.function中的复合方法
在java.util.function包中的很多函数式接口里，都定义了一些复合方法，我们看一些例子。
Function接口有如下定义：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));
}先将T类型的参数转化为类型R，再调用after将R转换为V，最后返回类型V。
还有如下定义：
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));
}对V类型的参数，先调用before将V转换为T类型，再调用当前的apply方法转换为R类型返回。
Consumer, Predicate等都有一些复合方法，它们大量被用于下节介绍的函数式数据处理API中，具体我们就不探讨了。
The above is the detailed content of What is a lambda expression? what's the function?. For more information, please follow other related articles on the PHP Chinese website!