Java 8 lambda表达式深度解析

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

"Java Closures and Lambda.pdf 是一本关于Java 8中引入的闭包和lambda表达式的深入解析书籍。本书旨在帮助读者理解并掌握Java 8的新特性，特别是如何利用lambda表达式来提升代码的简洁性和效率。" 在Java 8中，lambda表达式是一个重要的新特性，它使得函数式编程风格在Java中变得更为可行和直观。Lambda表达式允许开发者将匿名函数作为方法参数，或者直接嵌入到方法调用中，这极大地简化了处理集合、映射和流等操作的代码。第一章"Java8:It’saWholeNewJava"介绍了Java 8的整体变化，强调了lambda表达式如何改变了Java的编程范式。这一章可能会涵盖Java 8的其他新特性，如方法引用、默认方法以及新的日期和时间API。第二章"UnderstandingLambdasinJava8"详细阐述了lambda表达式的概念、语法和使用场景。读者可以在这里学习到如何定义和使用lambda表达式，以及它们与函数接口的关系。第三章"Lambda’sDomain:Collections,Maps,andStreams"关注lambda表达式在处理集合、映射和流时的应用。这里会讨论如何通过lambda表达式实现高效的集合操作，如过滤、映射和归约，以及如何使用流API进行并行处理。第四章"I/OwithLambdas"讲解了如何结合lambda表达式处理输入/输出任务，可能包括文件操作、网络通信等方面，展示了lambda在简化I/O处理中的作用。第五章"DataAccesswithLambdas"探讨了在数据库访问和其他数据存储系统中应用lambda表达式的方式，可能包括JDBC的改进和ORM框架的使用。第六章"LambdaConcurrency"深入讨论了lambda表达式与并发编程的结合，包括如何使用lambda来实现线程安全和高效的任务执行。第七章"LambdasandLegacyCode"关注在已有代码库中整合lambda表达式，如何优雅地迁移旧代码，以及如何处理lambda与非lambda代码的交互问题。第八章"LambdasinJavaBytecode"揭示了lambda表达式在Java字节码层面的表现，解释了它们如何被编译和优化，有助于理解lambda的底层实现。附录"A:ATourofParadigms"可能是对不同编程范式的概览，对比了面向对象、函数式以及其他编程风格，并探讨了它们在Java 8中的融合。 "Java Closures and Lambda.pdf"是学习和理解Java 8中lambda表达式和闭包不可或缺的资源，适合有一定Java基础并希望提升现代Java开发技能的程序员。这本书将引导读者从理论到实践，全面掌握这一改变游戏规则的特性。

Chapter 2 ■ Understanding Lambdas in Java 8

Listing 2-2. Identity Function Implemented Using an Anonymous Inner Class

public static <V> Function<V, V> identityFunctionAIC() {

return new Function<V, V>() {

@Override

public V apply(V value) {

return value;

}

};

}

Since Function is an interface, it is entirely possible to reimplement identityFunction() using an

anonymous inner class. The equivalent anonymous inner class implementation is given in Listing 2-2. If you

compare the two implementations, there are a few interesting things to note. First, the new format is much

more succinct. Second, the return found inside the anonymous inner class is implicit with the lambda:

the lambda is made up of a single statement, and so that statement’s value is implicitly returned. Third, the

lambda version has no explicit declaration of value’s type: the compiler infers out the type of value based on

the context in which the value is used. This is a capability called “type inference,” and it is one of the nicest

things to come out of functional programming languages.

The type inference is why Listing 2-1 had to be wrapped in a method: you need to provide a way for the

compiler to know the argument and return type of the function. It is possible to assign a lambda directly

to a variable, but things get a bit tricky here: after all, what’s the type? Truly old school Java developers

might be tempted to assign it to Object and circumvent the type of system completely, as in Listing 2-3. If

you do that, however, you will get a compiler error: the compiler needs to know what type you are trying to

implement. More modern Java developers would want to use generics to solve this purpose, as in Listing 2-4.

This will compile and work just fine. Unfortunately, that loses type information: the compiler no longer

knows the argument and return type are the same type. The method allows us to keep that information by

communicating all the type information that we have while remaining as generic as possible. If, however,

you knew that it was always going to be a Number, then you could define it as in Listing 2-5, and you’d get

all the succinct inline definition along with the type information. (The repetition of <Number,Number> in

Listing 2-5 is because both the argument and the return value are a Number: the first Number denotes the

argument’s type, the second Number denotes the return value’s type.) As a general rule, define lambdas

inline to the variable assignment if you know the concrete types, and define lambdas within methods

to capture more complex type information. Now that the Java compiler has type inference, that type

information is worth its weight in gold: don’t lose it!

Listing 2-3. Identity Function Assigned to an Object Variable

// This code does not compile

Object funObject = it -> it;

Listing 2-4. Identity Function Assigned to a Generic Function Variable

Function<?,?> function = it -> it;

Listing 2-5. Identity Function for Number Instances Assigned to a Function Variable

Function<Number,Number> function = it -> it;

Chapter 2 ■ Understanding Lambdas in Java 8

Lambdas as Closures

Java 8’s lambdas act as closures. Although the term “lambda” and “closure” are effectively interchangeable in

most programming conversations, there is a technical difference. The good news is that Java 8’s lambdas are

also closures, so you can call them either and be technically correct. Understanding the distinction, however,

helps you be clear about what you are saying.

The term lambda comes from a branch of mathematics exploring what can and cannot be computed,

specifically from a structure called the lambda calculus. The lambda calculus explores function application

as the primary action in computation, and so it works with functions in the most abstract sense, without

any consideration of what the function itself might represent or calculate. Functions themselves are the

relevant values in the lambda calculus. When programming languages borrow the term lambda from the

lambda calculus, they mean functions that can be treated as values. A lambda can be assigned to a variable

(or multiple variables), passed around as method arguments, and generally manipulated like one might

manipulate the values 2, true, or "foo".

The term closure, however, refers to a later innovation of the lambda. For Java developers, it is

easiest to think of the term closure as meaning encapsulating function. In the same way that an object can

encapsulate state and expose it through a particular API (such as properties exposing fields), a closure can

also encapsulate some state and then act on that state wherever and whenever the closure is invoked. The

“close” part of closure refers to “open” versus “closed” variables. This idea comes directly from mathematics:

a variable that does not have a value bound to it is said to be “open,” while a variable that does have a value

bound to it is said to be “closed.” A closure is a lambda that closes certain variables, and it does this by

enclosing a variable environment.

This may sound like a strange and technical concept, but it is actually quite familiar in practice. Before

Java 8 introduced lambdas, Java arguably already had closures in the form of anonymous inner classes.

Anonymous inner classes could capture variable state in one context and execute on it in another: see

Listing 2-6 as an example. In that case, the anonymous inner class implementing Greeter closes the variable

greeting. You knew you were creating a closure in Java whenever the compiler would insist that you add

final to your variable or parameter declaration.

Java 8’s lambdas also act as closures, meaning that they will capture variables that are in scope. This is

just like how the anonymous inner classes did it, and an equivalent example of a lambda as a closure is given

in Listing 2-7. As a bit of syntactic sugar, though, you no longer have to explicitly declare your variables as

final: the compiler implicitly makes enclosed variables final, and will raise a compiler error if they are not

treated as final.

Listing 2-6. Anonymous Inner Classes as a Closure

public interface Greeter {

String createGreeting(String whom);

}

public static void main(String[] args) {

// Create variable in this scope

final String greeting = "Hello, ";

This strange fact provides the opportunity for a rather annoying and pedantic yet useful interview question:

“Please write a closure in valid Java 7 syntax.”

We will address why the final variables are necessary in the section below named “Lambdas Should Always Be

Threadsafe.”

Chapter 2 ■ Understanding Lambdas in Java 8

Note that we have a different type: the method signature that we want is no arguments and returning

Number, but Function is an interface whose only method has a signature with a single argument, and so

we need a different interface to represent this different signature.

For lambdas without arguments, the

functional interface is Supplier: the name was picked because they are used to supply values without

needing any input.

It is also possible to have multi-argument lambdas. At this point, the syntax should be predictable: we

will again use parentheses to demarcate the argument list, and we will again use type inference to specify

our types. An example of a two-argument function (called a bifunction) is given in Listing 2-9. The functional

type for these kinds of methods is BiFunction. Java’s SDK does not contain support for lambdas with more

than two arguments, because you really shouldn’t be using lambdas for that kind of complex case. If you

really want to have a lambda with lots of arguments, see “Lambdas as Interface Implementations” below

for how to handle that case. It is also worth noting that you cannot use varargs (e.g., String... strings)

as a lambda argument type: you have to treat the varargs parameter as an array. This sad fact is due to an

unfortunate limitation in Java’s type system.

The good news is that there are limited cases when you need

to have three or more arguments or varargs: zero-, one-, and two-argument functions handle most of your

cases. Streams (covered in the next chapter) and currying (covered in the next subsection) provide for almost

all these cases.

Listing 2-9. String Concatenation Bifunction

BiFunction<String, String, String> concat = (a, b) -> a + b;

Partial Function Application and Mr. Curry’s Verb

Every culture and subculture has its own language that identifies members of the tribe. One of the weird

tribal codewords in the functional programming tribe is “currying,” which is a verb coined after the logician

Haskell Curry. To understand what it means to curry a function and why one might want to do it, let’s start in

another place: partial function application.

Partial function application is exactly what it says it is: the application of part of a function. Consider,

for instance, the string concatenation bifunction given in Listing 2-9. What if you wanted to concatenate the

same thing to the front of a number of strings? Repeating yourself is one of the cardinal sins of programming

(“DRY”), and passing the same argument in over and over and over again is certainly repeating yourself.

What you want is a version of the bifunction with the first argument fixed to a certain value. Fixing that first

argument is called “applying” the argument, and since you’re only fixing the first of two possible arguments,

the application is “partial.” In Listing 2-10, we demonstrate what we are doing when we do partial function

application: we are creating a Function that applies a fixed first argument to a BiFunction. The resulting

Function can then be applied over and over again to multiple arguments. In Listing 2-11, we see how this

is implemented: although Java does not provide a built-in partial function application method, it is simple

to write one. We simply accept the bifunction that we want to apply along with the first argument, and then

return a function that calls back to that bifunction with the first argument already set.

This is one of the places where Java is decidedly not a functional language: function types are still communicated via

interfaces, instead of being intrinsic within the language itself.

Some people claim that vargargs in lambdas are unnecessary, and that attempting to use them is a sign that you are doing

something wrong. If you want to see both the good and the bad of vararg lambdas, see JavaScript’s arguments object

and the places where it is directly used.

Chapter 2 ■ Understanding Lambdas in Java 8

Listing 2-10. Implicit Partial Function Application of String Concatenation

public static void main(String[] args) {

BiFunction<String, String, String> concat = (a,b) -> a + b;

greetFolks(whom -> concat.apply("Hello, ", whom));

}

public static void greetFolks(Function<String, String> greeter) {

for(String name : Arrays.asList("Alice", "Bob", "Cathy")) {

System.out.println(greeter.apply(name));

}

Listing 2-11. Explicit Partial Function Application of String Concatenation

public static void main(String[] args) {

BiFunction<String, String, String> concat = (a,b) -> a + b;

greetFolks(applyPartial(concat, "Hello, "));

}

public static <T,U,V> Function<U,V> applyPartial(

BiFunction<T,U,V> bif, T firstArgument

) {

return u -> bif.apply(firstArgument, u);

}

public static void greetFolks(Function<String, String> greeter) {

for(String name : Arrays.asList("Alice", "Bob", "Cathy")) {

System.out.println(greeter.apply(name));

}

Mr. Curry’s Verb and Functional Shape

Partial function application acts on one function and takes another. Programming at the level of functions

like this is where “functional programming” got its name, and functional programming languages encourage

you to think at this level instead of at the level of data and instructions. Think of functional arguments as

voids in a jigsaw puzzle. Only a specific shape will fill that void. Every method you have access to is a piece

of that jigsaw puzzle, and they each have a shape. The shape of those methods is defined by the arguments

that they take and the arguments that they return. Like jigsaw puzzle pieces, you can also connect the shapes

together to make new shapes. Functional programming is the art of connecting the appropriate method

shapes together to fit the functional void.

For instance, the greetFolks method in Listing 2-10 and 2-11 provides a void with the shape of

String ➤ String: to call that method, we need to provide a function that takes a string and returns a string.

Unfortunately, we only had (String ➤ String) ➤ String: we only had a function that takes two strings as

arguments and returns a string. That shape does not quite fit. So what we did was partially apply the first

argument, which shaved that first argument off the shape of the method. This left us with a function with the

required shape of String ➤ String.

剩余206页未读，继续阅读

浮舟

粉丝: 627
资源: 381

Java 8 lambda表达式深度解析

Java Closures and Lambda(Apress,2015)

Lambda Expressions in Java 8 无水印pdf

Apress - Java Closures and Lambda.2015

java-closures-lambda:Robert Fischer的“ Java Closures和Lambda”的源代码-java source code

closures&callbacks.md

Laravel开发-laravel-closures-container .zip.zip

secrets_of_javascript_closures.pdf

swift.pdf.zip_Swift_swift.pdf

UL 2255：2021 Receptacle Closures - 完整英文版（15页）.pdf

Using Swift with Cocoa and Objective-C.pdf

最新资源