深入学习Java 8 Lambda表达式

java8

lambda

需积分: 9 76 浏览量更新于2024-07-20 收藏 7.85MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"这是一本关于学习Java 8的书籍，重点介绍了Java 8中的Lambda表达式。" 在Java 8中，Lambda表达式是最重要的新特性之一，它极大地简化了函数式编程，使得Java语言更加简洁、高效。Lambda表达式允许我们将函数作为方法参数传递，或者将它们存储在变量中，甚至可以作为返回值。这种概念源自函数式编程，但在Java 8中被引入，为传统面向对象编程带来了新的活力。 Lambda表达式的语法简洁明了，其基本形式如下： ```java (parameters) -> expression ``` 这里的`parameters`代表函数的输入参数，`->`是箭头符号，表示参数与表达式之间的分隔，而`expression`则是基于这些参数的计算或操作。例如，一个简单的Lambda表达式 `(int a, int b) -> a + b` 表示一个接受两个整数并返回它们之和的函数。 Java 8还引入了函数式接口（Functional Interface），这是可以被Lambda表达式代表的接口。一个函数式接口只有一个抽象方法，如`java.util.function.Function<T,R>`，它接受类型为T的对象并返回类型为R的对象。`Runnable`接口也是一个函数式接口，它只有一个无参数的`run()`方法。在实际应用中，Lambda表达式常用于集合操作，如Java 8的Stream API。Stream API提供了丰富的操作符，如`filter()`, `map()`, `reduce()`, `collect()`等，它们可以链式调用，配合Lambda表达式进行数据处理。例如，我们可以用以下代码过滤出一个列表中所有偶数： ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6); numbers.stream() .filter(n -> n % 2 == 0) .forEach(System.out::println); ``` 此外，Java 8的Optional类也是Lambda表达式的一个应用场景，它帮助避免空指针异常。Optional对象可以封装一个可能为null的值，提供了一套检查和获取值的方法，使得代码更加清晰和安全。 Lambda表达式在并发编程中也大有用途。`java.util.concurrent.ExecutorService`接口的`execute()`方法接受一个Runnable对象，通过Lambda表达式，我们可以轻松地创建并执行线程： ```java ExecutorService executor = Executors.newFixedThreadPool(2); executor.execute(() -> { // Lambda表达式内的代码将在新线程中执行 }); ``` Java 8的Lambda表达式是Java向函数式编程迈进的重要一步，它使得代码更简洁、可读性更强，同时提高了代码的复用性和灵活性。在学习这本书时，读者会深入理解Lambda表达式及其在Java 8中的各种应用场景，包括函数式接口、Stream API、Optional类以及并发编程。通过实践和探索，可以有效提升Java开发能力。

资源详情

资源推荐

these declarations do not make the methods abstract. (Some interfaces in the Java API redeclare Object methods in order to attach

javadoc comments. Check out the Comparator API for an example.) More importantly, as you will see in Section 1.7 , “Default

Methods ,” on page 14 , in Java 8, interfaces can declare nonabstract methods.

To demonstrate the conversion to a functional interface, consider the Arrays.sort method. Its second parameter requires an instance of

Comparator , an interface with a single method. Simply supply a lambda:

Click here to view code image

Arrays.sort(words,

(first, second) -> Integer.compare(first.length(), second.length()));

Behind the scenes, the Arrays.sort method receives an object of some class that implements Comparator<String> . Invoking the compare

method on that object executes the body of the lambda expression. The management of these objects and classes is completely implementation

dependent, and it can be much more efficient than using traditional inner classes. It is best to think of a lambda expression as a function, not an

object, and to accept that it can be passed to a functional interface.

This conversion to interfaces is what makes lambda expressions so compelling. The syntax is short and simple. Here is another example:

Click here to view code image

button.setOnAction(event ->

System.out.println("Thanks for clicking!"));

That’s a lot easier to read than the alternative with inner classes.

In fact, conversion to a functional interface is the only thing that you can do with a lambda expression in Java. In other programming languages that

support function literals, you can declare function types such as (String, String) -> int , declare variables of those types, and use the

variables to save function expressions. However, the Java designers decided to stick with the familiar concept of interfaces instead of adding

function types to the language.

NOTE

You can’t even assign a lambda expression to a variable of type Object —Object is not a functional interface.

The Java API defines a number of very generic functional interfaces in the java.util.function package. (We will have a closer look at these

interfaces in Chapters 2 and 3 .) One of the interfaces, BiFunction<T, U, R> , describes functions with parameter types T and U and return

type R . You can save our string comparison lambda in a variable of that type:

Click here to view code image

BiFunction<String, String, Integer> comp

= (first, second) -> Integer.compare(first.length(), second.length());

However, that does not help you with sorting. There is no Arrays.sort method that wants a BiFunction . If you have used a functional

programming language before, you may find this curious. But for Java programmers, it’s pretty natural. An interface such as Comparator has a

specific purpose, not just a method with given parameter and return types. Java 8 retains this flavor. When you want to do something with lambda

expressions, you still want to keep the purpose of the expression in mind, and have a specific functional interface for it.

The interfaces in java.util.function are used in several Java 8 APIs, and you will likely see them elsewhere in the future. But keep in mind

that you can equally well convert a lambda expression into a functional interface that is a part of whatever API you use today.

NOTE

You can tag any functional interface with the @FunctionalInterface annotation. This has two advantages. The compiler checks

that the annotated entity is an interface with a single abstract method. And the javadoc page includes a statement that your interface is

a functional interface.

It is not required to use the annotation. Any interface with a single abstract method is, by definition, a functional interface. But using

the @FunctionalInterface annotation is a good idea.

Finally, note that checked exceptions matter when a lambda is converted to an instance of a functional interface. If the body of a lambda

expression may throw a checked exception, that exception needs to be declared in the abstract method of the target interface. For example, the

following would be an error:

Click here to view code image

Runnable sleeper = () -> { System.out.println("Zzz"); Thread.sleep(1000); };

// Error: Thread.sleep can throw a checked InterruptedException

Since the Runnable.run cannot throw any exception, this assignment is illegal. To fix the error, you have two choices. You can catch the

exception in the body of the lambda expression. Or assign the lambda to an interface whose single abstract method can throw the exception. For

example, the call method of the Callable interface can throw any exception. Therefore, you can assign the lambda to a Callable<Void> (if

you add a statement return null ).

1.4. Method References

Sometimes, there is already a method that carries out exactly the action that you’d like to pass on to some other code. For example, suppose you

simply want to print the event object whenever a button is clicked. Of course, you could call

Click here to view code image

button.setOnAction(event -> System.out.println(event));

It would be nicer if you could just pass the println method to the setOnAction method. Here is how you do that:

Click here to view code image

button.setOnAction( System.out::println );

The expression System.out::println is a method reference that is equivalent to the lambda expression x -> System.out.println(x) .

As another example, suppose you want to sort strings regardless of letter case. You can pass this method expression:

Click here to view code image

Arrays.sort(strings, String::compareToIgnoreCase)

As you can see from these examples, the :: operator separates the method name from the name of an object or class. There are three principal

cases:

• object :: instanceMethod

• Class :: staticMethod

• Class :: instanceMethod

In the first two cases, the method reference is equivalent to a lambda expression that supplies the parameters of the method. As already mentioned,

System.out::println is equivalent to x -> System.out.println(x) . Similarly, Math::pow is equivalent to (x, y) -> Math.pow(x,

y) .

In the third case, the first parameter becomes the target of the method. For example, String::compareToIgnoreCase is the same as (x, y)

-> x.compareToIgnoreCase(y) .

NOTE

When there are multiple overloaded methods with the same name, the compiler will try to find from the context which one you mean.

For example, there are two versions of the Math.max method, one for integers and one for double values. Which one gets picked

depends on the method parameters of the functional interface to which Math::max is converted. Just like lambda expressions,

method references don’t live in isolation. They are always turned into instances of functional interfaces.

You can capture the this parameter in a method reference. For example, this::equals is the same as x -> this.equals(x) . It is also

valid to use super . The method expression

super:: instanceMethod

uses this as the target and invokes the superclass version of the given method. Here is an artificial example that shows the mechanics:

Click here to view code image

class Greeter {

public void greet() {

System.out.println("Hello, world!");

}

class ConcurrentGreeter extends Greeter {

public void greet() {

Thread t = new Thread( super::greet );

t.start();

}

When the thread starts, its Runnable is invoked, and super::greet is executed, calling the greet method of the superclass.

NOTE

In an inner class, you can capture the this reference of an enclosing class as EnclosingClass .this:: method or EnclosingClass

.super:: method .

1.5. Constructor References

Constructor references are just like method references, except that the name of the method is new . For example, Button::new is a reference to

a Button constructor. Which constructor? It depends on the context. Suppose you have a list of strings. Then you can turn it into an array of

buttons, by calling the constructor on each of the strings, with the following invocation:

Click here to view code image

List<String> labels = ...;

Stream<Button> stream = labels.stream().map( Button::new );

List<Button> buttons = stream.collect(Collectors.toList());

We will discuss the details of the stream , map , and collect methods in Chapter 2 . For now, what’s important is that the map method calls the

Button(String) constructor for each list element. There are multiple Button constructors, but the compiler picks the one with a String

parameter because it infers from the context that the constructor is called with a string.

You can form constructor references with array types. For example, int[]::new is a constructor reference with one parameter: the length of the

array. It is equivalent to the lambda expression x -> new int[x] .

Array constructor references are useful to overcome a limitation of Java. It is not possible to construct an array of a generic type T . The

expression new T[n] is an error since it would be erased to new Object[n] . That is a problem for library authors. For example, suppose we

want to have an array of buttons. The Stream interface has a toArray method that returns an Object array:

Click here to view code image

Object[] buttons = stream.toArray();

But that is unsatisfactory. The user wants an array of buttons, not objects. The stream library solves that problem with constructor references. Pass

Button[]::new to the toArray method:

Click here to view code image

Button[] buttons = stream.toArray( Button[]::new );

The toArray method invokes this constructor to obtain an array of the correct type. Then it fills and returns the array.

1.6. Variable Scope

Often, you want to be able to access variables from an enclosing method or class in a lambda expression. Consider this example:

Click here to view code image

public static void repeatMessage(String text, int count) {

Runnable r = () -> {

for (int i = 0; i < count ; i++) {

System.out.println( text );

Thread.yield();

}

};

new Thread(r).start();

}

Consider a call

repeatMessage("Hello", 1000); // Prints Hello 1,000 times in a separate thread

Now look at the variables count and text inside the lambda expression. Note that these variables are not defined in the lambda expression.

Instead, these are parameter variables of the repeatMessage method.

If you think about it, something nonobvious is going on here. The code of the lambda expression may run long after the call to repeatMessage

has returned and the parameter variables are gone. How do the text and count variables stay around?

To understand what is happening, we need to refine our understanding of a lambda expression. A lambda expression has three ingredients:

1. A block of code

2. Parameters

3. Values for the free variables, that is, the variables that are not parameters and not defined inside the code

In our example, the lambda expression has two free variables, text and count . The data structure representing the lambda expression must store

the values for these variables, in our case, "Hello" and 1000 . We say that these values have been captured by the lambda expression. (It’s an

implementation detail how that is done. For example, one can translate a lambda expression into an object with a single method, so that the values

of the free variables are copied into instance variables of that object.)

NOTE

The technical term for a block of code together with the values of the free variables is a closure . If someone gloats that their

language has closures, rest assured that Java has them as well. In Java, lambda expressions are closures. In fact, inner classes have

been closures all along. Java 8 gives us closures with an attractive syntax.

As you have seen, a lambda expression can capture the value of a variable in the enclosing scope. In Java, to ensure that the captured value is

well-defined, there is an important restriction. In a lambda expression, you can only reference variables whose value doesn’t change. For example,

the following is illegal:

Click here to view code image

public static void repeatMessage(String text, int count) {

Runnable r = () -> {

while (count > 0) {

count--; // Error: Can't mutate captured variable

System.out.println(text);

Thread.yield();

}

};

new Thread(r).start();

}

There is a reason for this restriction. Mutating variables in a lambda expression is not threadsafe. Consider a sequence of concurrent tasks, each

updating a shared counter.

Click here to view code image

int matches = 0;

for (Path p : files)

new Thread(() -> { if (p has some property ) matches++; }).start();

// Illegal to mutate matches

If this code were legal, it would be very, very bad. The increment matches++ is not atomic, and there is no way of knowing what would happen if

multiple threads execute that increment concurrently.

NOTE

Inner classes can also capture values from an enclosing scope. Before Java 8, inner classes were only allowed to access final local

variables. This rule has now been relaxed to match that for lambda expressions. An inner class can access any effectively final local

variable—that is, any variable whose value does not change.

Don’t count on the compiler to catch all concurrent access errors. The prohibition against mutation only holds for local variables. If matches is an

instance or static variable of an enclosing class, then no error is reported, even though the result is just as undefined.

Also, it’s perfectly legal to mutate a shared object, even though it is unsound. For example,

Click here to view code image

List<Path> matches = new ArrayList<>();

for (Path p : files)

new Thread(() -> { if (p has some property ) matches.add(p); }).start();

// Legal to mutate matches, but unsafe

Note that the variable matches is effectively final . (An effectively final variable is a variable that is never assigned a new value after it has been