JAVA 8 新特性详解：《JAVA 8 in Action》五星级推荐

需积分: 9 133 浏览量更新于2024-07-18 收藏 9.2MB PDF 举报

"JAVA 8 in Action 是一本亚马逊5星推荐的最新经典入门书籍，专注于讲解JAVA 8的新特性，包括Lambdas、streams和functional-style programming等核心内容。" 《JAVA 8 in Action》是Java开发者入门和进阶的重要读物，由Raoul-Gabriel Urma、Mario Fusco和Alan Mycroft合著。本书详细介绍了Java 8引入的一系列革新性特性，旨在帮助读者更好地理解和应用这些新功能，提升开发效率。 1. **Lambda表达式**： Java 8引入的Lambda表达式是其最显著的改变之一。Lambda允许程序员以简洁、易读的方式表示匿名函数，这在处理函数式接口时特别有用。通过Lambda，你可以更直观地编写代码，减少冗余，提高代码可读性和维护性。 2. **流(Streams)**：流API是Java 8中的另一个关键特性，它提供了一种处理集合数据的新方式。流可以看作是从数据源（如集合、数组）到计算的一种抽象，支持串行和并行操作。通过filter、map、reduce等方法，可以实现数据过滤、转换和聚合，使代码更加简洁高效。 3. **函数式编程风格**： Java 8鼓励采用函数式编程风格，这使得代码更加简洁，易于测试和并行化。函数式编程强调使用纯函数，避免副作用，提高代码的复用性。在Java 8中，函数可以作为一等公民，可以作为参数传递，也可以作为返回值。 4. **方法引用和构造器引用**：方法引用和构造器引用是Lambda表达式的补充，它们提供了直接引用已有方法或构造器的能力，进一步简化了代码。 5. **Optional类**： Optional是Java 8为解决空指针异常问题引入的一个容器类。它可以用于表示一个值存在或不存在，从而避免了null值带来的潜在问题，提高了代码的健壮性。 6. **日期和时间API的更新**： Java 8改进了日期和时间的处理，引入了java.time包，包含LocalDate、LocalTime、LocalDateTime等类，提供更强大且易于使用的日期时间处理功能。 7. **默认方法**：在接口中引入了默认方法，允许接口具有实现。这使得接口能够随着新特性的添加而演进，而不破坏现有的实现。 8. **Parallel Collectors**： Java 8对集合框架进行了优化，添加了并行流和并行收集器，使得大规模数据处理时能充分利用多核处理器的优势，实现高效的并行计算。《JAVA 8 in Action》这本书不仅深入浅出地讲解了这些新特性，还提供了丰富的示例和实践案例，帮助读者将理论知识转化为实际技能。对于想要掌握Java 8新特性的开发者来说，这本书无疑是一份宝贵的参考资料。

ability of early browsers to (safely) execute Java code applets gave it a niche in universities,

whose graduates then populated industry. There was initial resistance to the additional run cost

of Java over C/C++, but machines got faster and programmer time became more and more

important. Microsoft’s C# further validated the Java-style object-oriented model.

But the climate is changing for the programming language ecosystem; programmers are

increasingly dealing with so-called big data (datasets of terabytes and up) and wishing to exploit

multicore computers or computing clusters effectively to process it. And this means using

parallel processing—something Java wasn’t previously friendly to.

You may have come across programming ideas from other programming niches (for example,

Google’s map-reduce or the relative ease of data manipulation using database query languages

such as SQL) that help you work with large volumes of data and multicore CPUs. Figure 1.1

summarizes the language ecosystem pictorially: think of the landscape as the space of

programming problems and the dominant vegetation for a particular bit of ground as the

favorite language for that program. Climate change is the idea that new hardware or new

programming influences (for example, “Why can’t I program in SQL-like style?”) mean that

different languages become the language of choice for new projects, just like increasing regional

temperatures mean grapes now thrive in higher latitudes. But of course there’s

hysteresis—many an old farmer will keep raising traditional crops. In summary, new languages

are appearing and becoming increasingly popular because they’ve adapted quickly to the climate

change.

cat file1 file2 | tr "[A-Z]" "[a-z]" | sort | tail -3

which (supposing file1 and file2 contain a single word per line) prints the three words from the

files that appear latest in dictionary order, after first translating them to lowercase. We say that

sort takes a stream of lines

[3]

as input and produces another stream of lines as output (the latter

being sorted), as illustrated in figure 1.2. Note that in Unix the commands (cat, tr, sort, and tail)

are executed concurrently, so that sort can be processing the first few lines before cat or tr has

finished. A more mechanical analogy is a car-manufacturing assembly line where a stream of

cars is queued between processing stations that each take a car, modify it, and pass it on to the

next station for further processing; processing at separate stations is typically concurrent even

though the assembly line is physically a sequence.

Purists will say a “stream of characters,” but it’s conceptually simpler to think that sort

reorders lines.

Figure 1.2. Unix commands operating on streams

Java 8 adds a Streams API (note the uppercase S) in java.util.stream based on this idea;

Stream<T> is a sequence of items of type T. You can think of it as a fancy iterator for now. The

Streams API has many methods that can be chained to form a complex pipeline just like Unix

commands were chained in the previous example.

The key motivation for this is that you can now program in Java 8 at a higher level of abstraction,

structuring your thoughts of turning a stream of this into a stream of that (similarly to how you

think when writing database queries) rather than one item at a time. Another advantage is that

Java 8 can transparently run your pipeline of Stream operations on several CPU cores on

disjoint parts of the input—this is parallelism almost for free instead of hard work using

Threads. We cover the Java 8 Streams API in detail in chapters 4–7.

1.1.3. Passing code to methods with behavior parameterization

The second programming concept added to Java 8 is the ability to pass a piece of code to an API.

This sounds awfully abstract. In the Unix example, you might want to tell the sort command to

1.1.4. Parallelism and shared mutable data

The third programming concept is rather more implicit and arises from the phrase “parallelism

almost for free” in our previous discussion on stream processing. What do you have to give up?

You may have to make some small changes in the way you code the behavior passed to stream

methods. At first, these changes might feel a little uncomfortable, but once you get used to them,

you’ll love them. You must provide behavior that is safe to execute concurrently on different

pieces of the input. Typically this means writing code that doesn’t access shared mutable data to

do its job. Sometimes these are referred to as pure functions or side-effect-free functions or

stateless functions, and we’ll discuss these in detail in chapters 7 and 13. The previous

parallelism arises only by assuming that multiple copies of your piece of code can work

independently. If there’s a shared variable or object, which is written to, then things no longer

work: what if two processes want to modify the shared variable at the same time? (Section 1.3

gives a more detailed explanation with a diagram.) You’ll find more about this style throughout

the book.

Java 8 streams exploit parallelism more easily than Java’s existing Threads API, so although it’s

possible to use synchronized to break the no-shared-mutable-data rule, it’s fighting the system

in that it’s abusing an abstraction optimized around that rule. Using synchronized across

multiple processing cores is often far more expensive than you expect, because synchronization

forces code to execute sequentially, which works against the goal of parallelism.

Two of these points (no shared mutable data and the ability to pass methods and

functions—code—to other methods) are the cornerstones of what’s generally described as the

paradigm of functional programming, which you’ll see in detail in chapters 13 and 14. In

contrast, in the imperative programming paradigm you typically describe a program in terms

of a sequence of statements that mutate state. The no-shared-mutable-data requirement means

that a method is perfectly described solely by the way it transforms arguments to results; in

other words, it behaves as a mathematical function and has no (visible) side effects.

1.1.5. Java needs to evolve

You’ve seen evolution in Java before. For example, the introduction of generics and using

List<String> instead of just List may initially have been irritating. But you’re now familiar with

this style and the benefits it brings (catching more errors at compile time and making code

easier to read, because you now know what something is a list of).

Other changes have made common things easier to express, for example, using a for-each loop

instead of exposing the boilerplate use of an Iterator. The main changes in Java 8 reflect a move

剩余496页未读，继续阅读

ww1ww1

粉丝: 2
资源: 26

JAVA 8 新特性详解：《JAVA 8 in Action》五星级推荐

Java 8 In Action_Java8_Action!_

JAVA 8 In Action 读书笔记(源码）[已更新]

java8stream源码-java8InAction:java8InAction

java8stream源码-Java8InAction:Java8InAction

java8stream源码-java8inaction-:java8inaction-

java8stream源码-Java8InAction-master:Java8InAction

java8stream源码-Java8InAction_forked:Java8InAction_forked

Java8InAction

Java 8 in Action

java8源码-p_java8InAction:根据Java8InAction写出来的一些例子，囊括所有Java8的新特性，是初学者及知识巩固

最新资源