Core Java for the Impatient (Cay S. Horstmann)（Z-Library）

【One-Line Pitch】 A fast, no-nonsense route into modern Java for developers who already program in another language and want to reach Java 21 fluency without wading through a 1,000-page reference. It trades hand-holding for density, so it rewards readers who can move quickly and fill gaps on their own. 【Book Arc】 - **Opening (~0%–10%)**: Orients you to the book's philosophy and structure — a concise, application-programmer-focused tour of Java SE 21 that deliberately skips GUI code and low-level data-structure implementation, then lays out the full chapter map from fundamentals through modules. - **Early (~10%–30%)**: Builds the language floor: program structure, compilation and the JVM, primitive types, strings, I/O, control flow, arrays, and the JShell REPL for experimentation without a full build cycle. - **Middle (~30%–55%)**: Moves into object-oriented and functional Java — classes, records, interfaces, lambdas, method references, inheritance, pattern matching, and reflection — the conceptual core of modern Java style. - **Late (~55%–80%)**: Covers the library skills working developers actually need: exceptions, assertions, logging, generics, the collections framework, streams, file and HTTP I/O, regular expressions, and serialization. - **Ending (~80%–100%)**: Tackles the harder platform topics — concurrent programming with modern library abstractions, annotations and annotation processing, and the Java Platform Module System including migration flags and modular JARs. 【Key Takeaways】 - **Modern Java replaces old idioms rather than adding to them** (Opening): lambdas, streams, records, and sealed classes mean many legacy patterns are no longer needed; the book is organized around what to use now, not what to unlearn gradually. - **Concurrency is taught through library abstractions, not raw threads** (Early): the author explicitly reframes concurrent programming around powerful high-level features instead of error-prone low-level constructs — a deliberate departure from older Java texts. - **The book targets application programmers, not computer scientists** (Early): it covers logging, files, and real-world concerns, but deliberately omits implementing linked lists by hand or writing a web server, so expect breadth over algorithmic depth. - **Records and sealed classes are treated as first-class constructs** (Middle): these are presented alongside classic OOP topics, signaling that modern Java's data-oriented style belongs in the fundamentals, not an appendix. - **Streams get unusually deep treatment** (Late): filtering, mapping, flatMapping, reductions, Optional, collectors, grouping, partitioning, downstream collectors, primitive streams, and parallel streams form one of the book's largest single-topic blocks. - **Generics are explained down to the JVM level** (Late): type bounds, variance and wildcards, erasure, restrictions, and reflection with generics are covered together, which matters because most generics confusion is really an erasure misunderstanding. - **The module system is covered as a migration problem, not just a concept** (Ending): naming, requiring, exporting, reflective access, modular JARs, automatic and unnamed modules, and command-line migration flags are all addressed. - **Java 21 preview features appear where relevant** (Early): JEP 445's simplified `main` method is shown with its `--enable-preview --source 21` requirement, so you see where the language is heading, not just where it is. 【Reading Tips】 - **Skim Chapters 1–2 if you already know another language.** The author assumes prior programming experience; the value here is Java-specific syntax and semantics (primitive ranges, string encoding, switch forms), not general concepts. - **Deep-read the streams and concurrency chapters.** These are where the book's "modern Java" promise pays off most, and where old idioms are most actively obsolete. - **Use JShell alongside the text.** The book introduces it early precisely so you can test expressions without compiling; this is the fastest way through the dense early chapters. - **Treat generics and modules as the hard spots.** Erasure and the module system are the two areas most likely to require a second pass or outside reference. - **Keep the companion site handy.** Runnable examples are hosted at the author's site rather than embedded fully in the text. 【Coverage Limits】 This guide is based on stratified excerpts covering the front matter, table of contents, preface, and early chapters in detail; later chapters are represented mainly by their section listings, so specific claims about their internal content are inferred from structure rather than read in full.