On page 179:

First, imperative style was the way of life in Java and most programmers are very familiar with that style, since that was the only option for a long time.

In other words: Java is a member of the family of ALGOL-style languages derived from ALGOL 60.

A subchapter that is missing may be;

Use Records

Functional languages allow creation of data structures “on the fly” (e.g. the LISP cons or the Clojure “map” construct), the near-equivalent seems to be the record. It is very useful in stream pipelines to create new forms of data to be passed rightwards. It’s definitely more informative than using general maps for this task.

However, records should probably not be used outside of a local context or even in an API, use proper classes for that.

In

Use Type Inference for Parameters

one might mention that using var for field declarations is a good thing and not shameful, unless it is better to write the whole type for clarity for the other members of the team. (but the IDE will inline a note on the type anyway)

A special note on

Datastructures

which for functional programming are either primitive and immutable or complex and “pretend immutable” by not allowing any modifications, only allowing 1) copying 2) creating a modified copy (which is done efficiently “under the hood”) Only dropping references to whole or parts of these structures will allow reduction in size via eventual garbage collection.

For example, in Clojure: Clojure - Data Structures

However, Java collections for example are not like that at all, at best we can make them immutable by wrapping with an “unmodifiable” decorator. What is to be done? Are there libraries that have tree structures (say) that efficiently implement “immutability” semantics.