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

【One-Line Pitch】 A comprehensive, example-driven reference for experienced programmers who want a deep, practical command of Java fundamentals—from syntax and OOP to generics, collections, and concurrency—updated through Java 21. 【Book Arc】 - **Opening (~0%–6%)**: Sets the stage with Java’s evolution (from Java 2 to 21), explains the book’s philosophy of realistic, non-trivial examples, and previews the core topics: OOP, reflection, interfaces, exceptions, generics, collections, lambdas, concurrency, annotations, and modules. - **Early (~6%–19%)**: Dives into the basics—comments, data types, operators, strings, and control flow—with practical warnings (e.g., non-nesting comments, string concatenation pitfalls) and introduces file I/O via `Scanner` and `PrintWriter`. - **Early (~19%–28%)**: Moves into object-oriented programming: classes, objects, static members, factory methods (e.g., `LocalDate`, `NumberFormat`), and the rationale behind design choices like immutability and naming conventions. - **Middle (~28%–44%)**: Covers inheritance, equality (`equals`/`hashCode`), final classes/methods, and the class path/JAR mechanics—essential for structuring real projects and understanding how Java locates and loads classes. - **Middle (~44%–47%)**: Explores collections (e.g., `ArrayList`), autoboxing, and the performance trade-offs of wrappers versus primitives, alongside deeper OOP topics like polymorphism and method overriding rules. - **Late (~47%–end)**: The excerpts taper off before covering advanced topics like generics, lambdas, concurrency, and modules in full; the book’s structure suggests these are treated with the same depth, using simple but non-trivial examples. 【Key Takeaways】 - **Java’s evolution matters for modern code** (Opening): Understanding version history (e.g., generics in 5.0, lambdas in 8, pattern matching in 21) helps you write idiomatic code and leverage new features without breaking compatibility. (Early) - **Comments and strings have hidden traps** (Early): `/* */` comments don’t nest, and string concatenation with `+` can produce surprising results (e.g., `"age" + 1 + "."` yields `"age1."`)—use parentheses or `StringBuilder` for clarity and efficiency. (Early) - **`StringBuilder` beats `StringBuffer` in single-threaded code** (Early): The former is more efficient; the latter is only needed for multi-threaded string editing. Chaining methods and reversing strings are practical idioms to master. (Early) - **Factory methods offer flexibility constructors can’t** (Early): `NumberFormat.getCurrencyInstance()` and `LocalDate.of()` show how static factories enable naming, subtype returns, and instance sharing—prefer them when constructors are too rigid. (Early) - **Immutability is a concurrency safety net** (Middle): Classes like `LocalDate` avoid mutation, making them safe for multi-threaded use. Prefer immutable designs to prevent unpredictable behavior when threads share objects. (Middle) - **The class path is the backbone of project structure** (Middle): Understanding how Java finds classes (via directories, JARs, and wildcards) is essential for building and sharing code—especially before modules take over encapsulation. (Middle) - **`equals` requires careful implementation** (Middle): Check identity, null, and class match before comparing fields; use `Objects.equals` to handle nulls safely. Getting this wrong breaks collections and debugging. (Middle) - **Autoboxing is convenient but costly** (Middle): `ArrayList<Integer>` wraps each `int` in an object, hurting performance versus `int[]`. Use wrappers only for small collections where convenience outweighs efficiency. (Middle) 【Reading Tips】 - **Skim the history and API notes** (Opening–Early): The version history and API notes are useful context but not essential for coding—skim them and focus on the code listings and warnings. - **Deep-read the “Caution” and “Note” boxes** (Early–Middle): These contain hard-won pitfalls (e.g., comment nesting, concatenation order, autoboxing overhead) that save you from common bugs. - **Run the examples yourself** (Early–Middle): The book’s examples are deliberately simple but non-trivial—type them into JShell or an IDE to internalize patterns like factory methods and `equals` implementation. - **Pay extra attention to the class path section** (Middle): This is a common stumbling block for beginners; work through the directory and JAR setup manually to avoid confusion in real projects. - **Treat the later chapters as a roadmap** (Late): The excerpts don’t cover generics, lambdas, concurrency, or modules in detail—use the book’s structure to plan your reading, and revisit these topics with the same example-driven approach. 【Coverage Limits】 This guide synthesizes the opening through middle sections (roughly 0–47% of the book). The excerpts do not cover the later chapters on generics, lambda expressions, concurrency, annotations, or the Java Platform Module System in depth.