Java 8 Lambda表达式实战

需积分: 9 62 浏览量更新于2024-07-19 收藏 4.04MB PDF 举报

"Java 8 Lambdas" 是一本由Richard Warburton编写的书籍，针对具有核心Java SE技能的开发者，介绍了Java 8中的一个重要语言更新——lambda表达式。本书通过代码示例、练习和流畅的解释，帮助读者理解如何使用lambda表达式编写简洁、清晰的库级别代码来解决业务问题。在Java 8中，lambda表达式的引入是语言的一个重大改进。Lambda表达式是一种匿名函数，允许将函数作为一个值传递，这使得代码更加简洁且易于理解。书中首先深入浅出地介绍了如何正确使用lambda表达式，包括它们的基本语法和用法。随着阅读的深入，读者会发现lambda表达式在提升性能方面的作用，尤其是在并行处理中的应用。它们使得并行编程变得更加简单，从而能充分利用多核处理器的优势，提高程序执行效率。此外，lambda表达式还简化了并发代码的编写。在Java 8之前，处理并发可能需要对线程管理和同步有深入的理解，而lambda表达式结合Stream API，可以更直观地表达并行操作，降低了并发编程的复杂性。更重要的是，lambda表达式有助于更准确地建模业务领域。它们能够帮助构建更好的领域特定语言（DSL），使代码更接近自然语言，提升代码的可读性和可维护性。DSL的创建使得非程序员也能更容易理解代码，从而促进团队间的沟通和协作。这本书受到了行业专家的高度评价，认为它是每一个希望掌握Java 8新特性的开发者必读之作。通过阅读本书，开发者不仅能学习到lambda表达式的具体用法，还能理解其背后的动机，以及何时何地应当使用它们来优化自己的代码库。 "Java 8 Lambdas" 是一本全面介绍Java 8核心特性——lambda表达式的实践指南，它将帮助读者深入理解这一改变游戏规则的新特性，并将其有效地应用于实际项目中，提升开发效率和代码质量。对于想要与时俱进，熟练掌握现代Java编程的开发者来说，这本书无疑是一份宝贵的资源。

and time associated with developing enterprise business applications, and any barrier

to developing easy-to-use and efficient libraries should be removed.

Abstraction is a concept that is familiar to us all from object-oriented programming.

The difference is that object-oriented programming is mostly about abstracting over

data, while functional programming is mostly about abstracting over behavior. The real

world has both of these things, and so do our programs, so we can and should learn

from both influences.

There are other benefits to this new abstraction as well. For many of us who aren’t writing

performance-critical code all the time, these are more important wins. You can write

easier-to-read code—code that spends time expressing the intent of its business logic

rather than the mechanics of how it’s achieved. Easier-to-read code is also easier to

maintain, more reliable, and less error-prone.

You don’t need to deal with the verbosity and readability issues surrounding anonymous

inner classes when writing callbacks and event handlers. This approach allows pro‐

grammers to work on event processing systems more easily. Being able to pass functions

around easily also makes it easier to write lazy code that initializes values only when

necessary.

In addition, the language changes that enable the additional collection methods, de

fault methods, can be used by everyday programmers who are maintaining their own

libraries.

It’s not your grandfather’s Java any longer, and that’s a good thing.

What Is Functional Programming?

Functional programming is a term that means different things to different people. At

the heart of functional programming is thinking about your problem domain in terms

of immutable values and functions that translate between them.

The communities that have developed around different programming languages each

tend to think that the set of features that have been incorporated into their language are

the key ones. At this stage, it’s a bit too early to tell how Java programmers will define

functional programming. In a sense, it’s unimportant; what we really care about is writ‐

ing good code rather than functional code.

In this book, I focus on pragmatic functional programming, including techniques that

can be used and understood by most developers and that help them write programs that

are easier to read and maintain.

2 | Chapter 1: Introduction

Anonymous inner classes were designed to make it easier for Java programmers to pass

around code as data. Unfortunately, they don’t make it easy enough. There are still four

lines of boilerplate code required in order to call the single line of important logic. Look

how much gray we get if we color out the boilerplate:

button.addActionListener(new ActionListener() {

public voidactionPerformed(ActionEvent event) {

System.out.println("button clicked");

}

});

Boilerplate isn’t the only issue, though: this code is fairly hard to read because it obscures

the programmer’s intent. We don’t want to pass in an object; what we really want to do

is pass in some behavior. In Java 8, we would write this code example as a lambda

expression, as shown in Example 2-2.

Example 2-2. Using a lambda expression to associate behavior with a button click

button.addActionListener(event -> System.out.println("button clicked"));

Instead of passing in an object that implements an interface, we’re passing in a block of

code—a function without a name. event is the name of a parameter, the same parameter

as in the anonymous inner class example. -> separates the parameter from the body of

the lambda expression, which is just some code that is run when a user clicks our button.

Another difference between this example and the anonymous inner class is how we

declare the variable event. Previously, we needed to explicitly provide its type—Actio

nEvent event. In this example, we haven’t provided the type at all, yet this example still

compiles. What is happening under the hood is that javac is inferring the type of the

variable event from its context—here, from the signature of addActionListener. What

this means is that you don’t need to explicitly write out the type when it’s obvious. We’ll

cover this inference in more detail soon, but first let’s take a look at the different ways

we can write lambda expressions.

Although lambda method parameters require less boilerplate code

than was needed previously, they are still statically typed. For the sake

of readability and familiarity, you have the option to include the type

declarations, and sometimes the compiler just can’t work it out!

How to Spot a Lambda in a Haystack

There are a number of variations of the basic format for writing lambda expressions,

which are listed in Example 2-3.

6 | Chapter 2: Lambda Expressions

剩余181页未读，继续阅读

litianren01

粉丝: 0

Java 8 Lambda表达式实战

奥莱理 Java 8 Lambdas 学习笔记

Java8 Lambdas 函数式编程百度网盘

深入理解Java 8 Lambdas

深入解析Java 8 Lambdas

深入理解Java 8 Lambdas与流处理

Java8 Lambdas精讲：新特性与实战指南

Java 8 Lambdas教程：匿名函数与并行性能提升

深入理解Java 8 Lambda表达式

Java 8 Lambda教程：入门与实战

Java 8 Lambda：函数式编程入门

最新资源