Book #8 - Modern Java in Action

20.1 Introduction to Scala

Sean

20.2 Functions

Sean

20.3 Classes and traits

Sean

21.1 Review of Java 8 features

Casey

21.2 The Java 9 module system

Casey

21.3 Java 10 local variable type inference

Casey

21.4 What’s ahead for Java?

Casey

21.5 Moving Java forward faster
21.6 The final word

Casey

Appendix C

Casey

18.1 Implementing and maintaining systems

Sean

18.2 What’s functional programming?

Sean

18.3 Recursion vs. iteration

Sean

19.1 Functions everywhere

Sean

19.2 Persistent data structures

Casey

19.3 Lazy evaluation with streams

Casey

19.4 Pattern matching

Casey

19.5 Miscellany

Casey

16.1 Simple use of Futures

Sean

16.2 Implementing an asynchronous API

Sean

16.3 Making your code nonblocking

Sean

16.4 Pipelining asynchronous tasks

Sean

16.5 Reacting to a CompletableFuture completion

Sean

17.1 The Reactive Manifesto

Casey

17.2 Reactive streams and the Flow API

Casey

17.3 Using the reactive library RxJava

Casey

Introduction

Casey

15.1 Evolving Java support for expressing concurrency

Casey

15.2 Synchronous and asynchronous APIs

Sean

15.3 The box-and-channel model

Sean

15.4 CompletableFuture and combinators for concurrency

Casey

15.5 Publish-subscribe and reactive programming

Sean

15.6 Reactive systems vs. reactive programming

Sean

14.1 The driving force: reasoning about software

Casey

14.2 Why the Java Module System was designed

Casey

14.3 Java modules: the big picture

Casey

14.4 Developing an application with the Java Module System

Casey

14.5 Working with several modules

Sean

14.6 Compiling and packaging

Sean

14.7 Automatic modules

Sean

14.8 Module deployment and clauses

Sean

14.9 A bigger example and where to learn more

Sean

11.1 How do you model the absence of a value
11.2 Introducing the Optional class
11.3 Patterns for adopting Optionals
11.4 Practical examples of using Optional

Sean

12 .1 LocalDate, LocalTime, LocalDateTime, Instant, Duration, and Period
12.2 Manipulating, parsing, and formatting dates
12.3 Working with different time zones and calendars

Sean

13.1 Evolving APIs
13.2 Default methods in a nutshell
13.3 Usage patterns for default methods
13.4 Resolution rules

Casey

10.1 A specific language for your domain

Sean G

10.2 Small DSLs in modern Java APIs

Casey

10.3 Patterns and techniques to create DSLs in Java

Sean G

10.4 Real World Java 8 DSL

Casey

9.1 Refactoring for improved readability and flexibility

Casey

9.2 Refactoring object-oriented design patterns with lambdas

Tejas

9.3 Testing lambdas

Sean

9.4 Debugging

Casey

7.1 Parallel streams

Sean

7.2 The fork/join framework

Casey

7.3 Spliterator

Sean

8.1 Collection factories

Casey

8.2 Working with List and Set

Casey

8.3 Working with Map

Casey

8.4 Improved ConcurrentHashMap

Casey

6.1 Collectors in a nutshell

Casey

6.2 Reducing and summarizing

Casey

6.3 Grouping

Casey

6.4 Partitioning

Casey

6.5 The Collector interface

Sean

6.6 Developing your own collector for better performance

Sean

4.1 What are streams?

Casey

4.2 Getting started with streams

Casey

4.3 Streams vs collections

Casey

4.4 Stream operations

Casey

4.5 Road map

Casey

5.1 Filtering

Sean

5.2 Slicing a stream

Sean

5.3 Mapping

Sean

5.4 Finding and matching

Sean

5.5 Reducing

Sean

5.6 Putting it all into practice

Sean

5.7 Numeric streams

Sean

5.8 Building streams

Sean

5.9 Overview

Sean

3.1 Lambdas in a nutshell

Casey

3.2 Where and how to use lambdas

Sean

3.3 Putting lambdas into practice: the execute-around pattern

Casey

3.4 Using functional interfaces

Sean

3.5 Type checking, type inference, and restrictions

Casey

3.6 Method references

Sean

3.7 Putting lambdas and method references into practice

Sean

3.8 Useful methods to compose lambda expressions

Casey

3.9 Similar ideas from mathematics

Casey

Introduction
2.1 Coping with changing requirements

Casey

2.2 Behavior parameterization

Sean

2.3 Tackling verbosity

Casey

2.4 Real-world examples

Sean