Java Generics and Collections, 2nd Edition (Maurice Naftalin, Philip Wadler, Stuart Marks) (Z-Library)

【One-Line Pitch】 A rigorous but readable guide to Java's generic type system and the Collections Framework, updated for Java 21. Best for intermediate-to-advanced Java developers who want to write correct, type-safe generic APIs and choose the right collection for every job. 【Book Arc】 - **Opening (~0%–10%)**: Introduces the purpose of generics—reusing code across types while preserving type safety—and establishes the two kinds of generic code: generic types and generic methods. Covers primitive/reference type mapping and the basics of wildcards. - **Early (~10%–32%)**: Moves into the get-and-put principle for wildcards, wildcard capture, and the Comparable contract. Then tackles erasure, bridge methods, nested classes, and the tricky relationship between generics and arrays (reification, unchecked casts, the Principle of Truth in Advertising and the Principle of Indecent Exposure). - **Middle (~32%–48%)**: Explores reflection over generic types, enforcing type safety when calling untrusted code (checked collections, wary brokers), and using type tokens for run-time type information. Transitions into the Collections Framework, starting with the List/Set distinction and the role of views. - **Late (~48% onward)**: Dives into the Collections API in depth—views, optional operations, immutability vs. unmodifiability, and performance analysis with O-notation. The excerpts indicate the book continues into stream processing and how collection and stream models interoperate. - **Ending**: The excerpts do not cover the final chapters in detail, but the blurb indicates the book closes with guidance on choosing between collection and stream processing models and getting the best out of the platform library. 【Key Takeaways】 - **Generics exist to reuse code across types while preventing type confusion** (Opening): `List<String>` and `List<Integer>` share implementation but are distinct types, and the compiler enforces the boundary. - **The get-and-put principle governs wildcard usage** (Early): use `? extends T` when you only read from a structure, `? super T` when you only write to it, and avoid wildcards when you do both. - **Wildcard capture explains seemingly identical types that are not the same** (Early): two occurrences of `? extends Number` may represent different unknown subtypes, so you cannot freely move values between them. - **Erasure creates real hazards with arrays and unchecked casts** (Early): the Principle of Truth in Advertising and the Principle of Indecent Exposure are practical rules for avoiding class cast exceptions that appear far from their source. - **Bridge methods are the hidden machinery that makes generic overriding work** (Early): they are synthetic methods generated by the compiler when a class implements a parameterized supertype, and they matter for binary compatibility. - **Checked collections and type tokens are tools for enforcing type safety at API boundaries** (Middle): when calling untrusted code, wrap collections with `Collections.checkedList` and use `Class<T>` tokens to carry run-time type information. - **Collections differ in ordering, uniqueness, and performance guarantees** (Middle): lists maintain order, sets enforce uniqueness, and the choice among them should be driven by the operations you need, not habit. - **Views and optional operations are a deliberate, sometimes controversial design** (Middle): many collection methods return views with varying permissiveness, from fully modifiable to fully unmodifiable, and understanding these rules prevents subtle bugs. 【Reading Tips】 - **Deep-read the wildcard and erasure chapters (Early)**: these are the conceptual core; skimming them will make later chapters on reflection and arrays much harder. - **Skim the reflection chapter if you rarely use it**: the material on `Class<T>`, type tokens, and reflecting generic types is valuable but specialized; return to it when you need it. - **Use the collections chapters as a reference**: read the List/Set/Map overview once, then revisit specific collection types when you face a real design decision. - **Pay attention to the principles and contracts**: the Principle of Truth in Advertising, the Principle of Indecent Exposure, and the Comparable contract are memorable rules that generalize beyond the examples. - **Run the code examples**: the book's repository includes fragments that sometimes do not compile, and the explanations for those failures are part of the lesson. 【Coverage Limits】 The excerpts cover generics, erasure, reflection, type safety, and the early-to-middle portions of the Collections Framework in detail, but the later chapters on stream processing and the final collection implementations are only partially represented. Specific chapter titles and the full ending are not covered by the excerpts.