Java 8 Lambda表达式教程和示例

摘要：此篇文章主要介绍 JAVA8 Lambda 表达式产生的背景和用法，以及 Lambda 表达式与匿名类的不同等。采用Google翻译。

Java是一流的面向对象语言。除了原始数据类型外，Java中的所有内容都是对象。甚至数组也是一个对象。每个类都创建作为对象的实例。没有办法仅定义一个完全保留在Java中的函数/方法。无法将方法作为参数传递或返回该实例的方法主体。

从Swing的旧时代开始，如果我们想将某些功能传递给任何方法，我们总是编写匿名类。例如，过去的旧事件监听器代码如下所示：

someObject.addMouseListener(new MouseAdapter() {
    public void mouseClicked(MouseEvent e) {
        //Event listener implementation goes here...
    }
});

在这里，我们想向鼠标侦听器添加一些自定义代码。我们定义了一个匿名内部类MouseAdapter并创建了它的对象。这样，我们将一些功能传递给addMouseListener方法。简而言之，在Java中传递可以作为参数传递的简单方法/功能并不容易。由于此限制，Java 8添加了一个称为Lambda Expressions的全新语言级别功能。

为什么Java需要Lambda表达式？

从一开始，如果您忽略诸如注释，泛型等某些功能，Java语言就不会有太大的发展。在Java语言的一生中，通常始终是对象优先的语言。在使用了JavaScript之类的功能语言之后，人们很清楚Java是如何强制执行其严格的面向对象性质和在源代码上进行严格类型化的。您会看到函数对于Java不重要。他们不能独自生活在Java世界中。

函数是函数式编程语言中的一等公民。它们独立存在。您可以将它们分配给变量，并将它们作为参数传递给其他函数。JavaScript是FP语言的最佳示例之一。这里和这里有一些好文章清楚地描述了JavaScript作为功能语言的好处。功能语言提供了一种非常强大的功能，称为Closure，与传统的编写应用程序方式相比，它具有许多优点。闭包是一个函数或对该函数的引用以及一个引用环境-一个表，该表存储对该函数的每个非局部变量的引用。Java可以提供给Closure的最接近的东西是Lambda表达式。Closure和Lambda表达式之间存在显着差异，但是至少Lambda表达式提供了Closure的很好选择。在他讽刺而有趣的博客文章中，史蒂夫·耶格（Steve Yegge）描述了Java世界严格地讲名词。如果您尚未阅读他的博客，请先阅读。这很有趣，很有趣，它描述了Java必须添加Lambda表达式的确切原因。Lambda表达式增加了函数式编程与Java的缺失链接。Lambda表达式让我们具有一流公民的功能。尽管这不是100％正确的，但我们很快就会看到Lambda表达式不是闭包，但它们与闭包尽可能地接近。在支持一等函数的语言中，lambda表达式的类型将是函数；但是在Java中，lambda表达式表示为对象，因此必须将它们绑定到称为功能接口的特定对象类型。我们将详细了解什么是功能接口。这里有一个Mario Fusco 写的一篇很好的文章，内容涉及为什么我们需要Java中的Lambda表达式。他解释了为什么现代编程语言必须具有闭包之类的功能。

Lambda表达式简介

Lambda表达式是一个匿名函数（对于Java，不是100％正确，但是暂时假设它）。简而言之，它是没有声明的方法，即访问修饰符，返回值声明和名称。这是一种简写形式，可让您在将要使用的位置编写方法。在仅使用一种方法且方法定义简短的地方特别有用。它省去了为包含的类声明和编写单独的方法的工作。Java中的Lambda表达式通常使用语法编写(argument) -> (body)。例如：

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

以下是Lambda表达式的一些示例。

(int a, int b) -> { return a + b; }

() -> System.out.println("Hello World");

(String s) -> { System.out.println(s); }

() -> 42

() -> { return 3.1415 };

Lambda表达式的结构

让我们检查lambda表达式的结构。

• Lambda表达式可以具有零个，一个或多个参数。
• 参数的类型可以显式声明，也可以从上下文中推断出来。例如(int a)与(a)
• 参数用括号括起来，并用逗号分隔。例如，(a, b)或(int a, int b)或(String a, int b, float c)
• 空括号用于表示空参数集。例如() -> 42
• 当有单个参数时，如果推断出其类型，则不强制使用括号。例如a -> return a*a
• Lambda表达式的主体可以包含零个，一个或多个语句。
• 如果lambda表达式的主体具有单个语句，则不必使用大括号，并且匿名函数的返回类型与主体表达式的返回类型相同。
• 如果正文中有多个语句，则必须将这些语句括在大括号（一个代码块）中，并且匿名函数的返回类型与该代码块内返回的值的类型相同；如果没有，则返回void回。

什么是功能接口

在Java中，标记接口是没有方法或字段声明的接口。简而言之，标记器接口是一个空接口。同样，功能接口是仅声明了一个抽象方法的接口。 java.lang.Runnable是功能接口的示例。void run()在Runnable接口中仅声明一种方法。同样，ActionListener接口也是功能接口。我们使用匿名内部类实例化功能接口的对象。使用Lambda表达式，可以简化此过程。每个lambda表达式可以隐式分配给一个称为Functional interface的接口。例如，我们可以从lambda表达式创建Runnable接口的引用，如下所示：

Runnable r = () -> System.out.println("hello world");

当我们不指定功能接口时，编译器会自动处理这种类型的转换。例如：

new Thread(
() -> System.out.println("hello world")
).start();

因此，在上述代码中，编译器自动推论可以将lambda表达式从Thread类的构造函数签名强制转换为Runnable接口public Thread(Runnable r) { }。lambda表达式及其功能接口的几个示例：

Consumer<Integer> c = (int x) -> { System.out.println(x) };

BiConsumer<Integer, String> b = (Integer x, String y) -> System.out.println(x + " : " + y);

Predicate<String> p = (String s) -> { s == null };

@FunctionalInterface是Java 8中添加的新接口，用于指示接口类型声明旨在作为Java语言规范所定义的功能接口。Java 8还声明了Lambda表达式可以使用的功能接口的数量。当您注释的接口不是有效的Functional Interface时，@ FunctionalInterface可用于编译器级别的错误。以下是自定义定义的功能接口的示例。

@FunctionalInterface
public interface WorkerInterface {

public void doSomeWork();

}

顾名思义，功能接口只能有一种抽象方法。如果尝试在其中添加另一个抽象方法，则会引发编译时错误。例如：

@FunctionalInterface
public interface WorkerInterface {

public void doSomeWork();

public void doSomeMoreWork();

}

错误：

Unexpected @FunctionalInterface annotation
@FunctionalInterface ^ WorkerInterface is not a functional interface multiple
non-overriding abstract methods found in interface WorkerInterface 1 error

定义了Functional接口之后，我们可以在API中简单地使用它并利用Lambda表达式。例如：

//define a functional interface
@FunctionalInterface
public interface WorkerInterface {

public void doSomeWork();

}

public class WorkerInterfaceTest {

public static void execute(WorkerInterface worker) {
worker.doSomeWork();
}

public static void main(String [] args) {

//invoke doSomeWork using Annonymous class
execute(new WorkerInterface() {
@Override
public void doSomeWork() {
System.out.println("Worker invoked using Anonymous class");
}
});

//invoke doSomeWork using Lambda expression
execute( () -> System.out.println("Worker invoked using Lambda expression") );
}

}

输出：

Worker invoked using Anonymous class
Worker invoked using Lambda expression

在这里，我们创建了自己的Functional接口，并习惯了lambda表达式。execute（）方法现在可以将lambda表达式用作参数。

Lambda表达的例子

学习Lambda表达式的最佳方法是通过示例。以下是一些示例：可以像下面这样初始化线程：

//Old way:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello from thread");
}
}).start();

//New way:
new Thread(
() -> System.out.println("Hello from thread")
).start();

可以使用lambda表达式在Java 8中完成事件处理。以下代码展示了将ActionListener添加到UI组件的新旧方式。

//Old way:
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("The button was clicked using old fashion code!");
}
});

//New way:
button.addActionListener( (e) -> {
System.out.println("The button was clicked. From lambda expressions !");
});

简单的代码即可打印给定数组的所有元素。请注意，还有一种使用lambda表达式的方法。在下面的示例中，我们使用了使用箭头语法创建lambda表达式的常用方法，并且还使用了Java 8必须将常规方法转换为lambda表达式的全新双冒号（：:)运算符。

//Old way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for(Integer n: list) {
System.out.println(n);
}

//New way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
list.forEach(n -> System.out.println(n));

//or we can use :: double colon operator in Java 8
list.forEach(System.out::println);

在此示例中，我们使用谓词功能接口创建测试并打印通过测试的元素。这样，您可以使用lambda表达式提供逻辑并基于该逻辑做一些事情。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main {

public static void main(String [] a) {

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

System.out.println("Print all numbers:");
evaluate(list, (n)->true);

System.out.println("Print no numbers:");
evaluate(list, (n)->false);

System.out.println("Print even numbers:");
evaluate(list, (n)-> n%2 == 0 );

System.out.println("Print odd numbers:");
evaluate(list, (n)-> n%2 == 1 );

System.out.println("Print numbers greater than 5:");
evaluate(list, (n)-> n > 5 );

}

public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {
for(Integer n: list) {
if(predicate.test(n)) {
System.out.println(n + " ");
}
}
}

}

输出：

Print all numbers: 1 2 3 4 5 6 7
Print no numbers:
Print even numbers: 2 4 6
Print odd numbers: 1 3 5 7
Print numbers greater than 5: 6 7

一些使用Lambda表达式的向导可以打印列表中每个元素的正方形。注意，我们使用.stream（）方法将常规列表转换为流。Java 8添加了一些很棒的Stream API。java.util.stream.Stream接口附带了许多有用的方法，这些方法可以与lambda表达式一起使用来进行伏都教。我们将lambda表达式传递x -> x*x给map（）方法，该表达式将该表达式应用于流的所有元素。之后，我们使用forEach打印列表的所有元素。

//Old way:
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
for(Integer n : list) {
int x = n * n;
System.out.println(x);
}

//New way:
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
list.stream().map((x) -> x*x).forEach(System.out::println);

给定一个列表，求和该列表中每个元素的平方。在单个语句中了解如何使用Lambda表达式实现此目的。这也是MapReduce上的入门示例。我们使用map（）将每个元素平方，然后用reduce（）将所有元素简化为单个数字。

//Old way:
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = 0;
for(Integer n : list) {
int x = n * n;
sum = sum + x;
}
System.out.println(sum);

//New way:
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = list.stream().map(x -> x*x).reduce((x,y) -> x + y).get();
System.out.println(sum);

Lambda表达式和匿名类之间的区别

使用匿名类和Lambda表达式之间的一个主要区别是使用this关键字。对于匿名类，“ this”关键字解析为匿名类，而对于lambda表达式，“ this”关键字解析为编写lambda的封闭类。lambda表达式和匿名类之间的另一个区别是这两种编译方式。Java编译器将编译lambda表达式并将其转换为该类的私有方法。它使用invokedynamicJava 7中添加的指令来动态绑定此方法。Tal Weiss 写了一个很好的博客，介绍Java如何将lambda表达式编译为字节码。

到此为止

Oracle首席架构师Mark Reinhold 将 Lambda表达式描述为有史以来最大的编程模型升级，甚至比泛型还要大。那么为何不。与其他功能编程语言相比，它为Java程序员提供了它所缺乏的优势。与虚拟扩展方法之类的其他功能一起，可以使用Lambda表达式编写一些非常好的代码。我希望本文可以让我们对Java 8中的商店一目了然。Ciao 🙂

图片来源：

• http://xkcd.com/1270/
• http://www.takipiblog.com/2014/01/16/compiling-lambda-expressions-scala-vs-java-8/

原文地址：http://viralpatel.net/blogs/Lambda-expressions-java-tutorial/