Core Java, Volume II Advanced Features, 13th Edition (Cay S. Horstmann)（Z-Library）

【One-Line Pitch】 A no-nonsense, example-driven tour of the Java libraries that professional developers actually reach for—streams, I/O, databases, networking, XML, and more—fully refreshed for Java 21. Best for programmers who already know core Java and want a trustworthy reference for the advanced APIs. 【Book Arc】 - **Opening (~0%–10%)**: Front matter, preface, and the full table of contents establish the book's scope and its split from Volume I—this volume covers libraries, not language fundamentals. - **Early (~10%–30%)**: The "Tour of This Book" maps all thirteen chapters and explains conventions (monospace code, notes, tips, cautions, C++ asides, API version numbers), so you can plan a non-linear reading path. - **Middle (~30%–50%)**: The Stream API opens the technical content—moving from external iteration to a "what, not how" style, stream creation, transformations, reductions, and parallel streams. - **Middle (~50%–70%)**: I/O and serialization, then XML parsing/generation/XPath, then networking including the HTTP client and simple HTTP server. - **Late (~70%–90%)**: Database programming via JDBC and SQL, followed by the remaining library chapters (date/time, scripting, compilation, internationalization, security). - **Ending (~90%–100%)**: Swing and Java 2D graphics, then native methods—including the Windows registry example and a preview of the "Panama" API that will replace the current native interface. 【Key Takeaways】 - **Streams reframe computation as intent, not procedure** (Middle): You declare filtering, mapping, and counting; the library chooses execution order and can parallelize via `parallelStream`, which matters for multi-core data processing. - **Streams are not collections** (Middle): They don't store elements, don't mutate their source, and are often lazily generated—so `filter` yields a new stream rather than removing anything. - **Stream creation is broader than collections** (Middle): `Stream.of`, `Arrays.stream`, `Stream.empty`, `generate`, `iterate` (with and without a stop predicate), `ofNullable`, plus `String.lines`, `Pattern.splitAsStream`, `Scanner.tokens`, and `Files.lines`. - **I/O is unified through streams and readers/writers** (Middle): The same abstractions cover files, network connections, and memory blocks, with explicit attention to Unicode handling and object serialization internals. - **XML work spans the full lifecycle** (Middle): Parsing, validating, locating data with XPath, namespaces, streaming parsers, generating documents, and XSL transformations—illustrated with a Swing form layout. - **Networking is made approachable** (Middle): Connecting to servers, implementing your own servers, fetching web data, and using the newer HTTP client and simple HTTP server. - **JDBC is the bridge to relational data** (Late): Design of JDBC, SQL, configuration, statements, query execution, and scrollable/updatable result sets. - **Native methods trade portability for platform access** (Ending): Necessary when Java lacks support for a device or service; the Windows registry example shows the pattern, and Panama signals the future direction. 【Reading Tips】 - Treat this as a reference, not a linear read: the author states chapters are largely independent, so jump to the topic you need. - Deep-read Chapter 1 (Streams) if you're new to the functional style—the "what, not how" mental model underpins later chapters. - Skim the front matter and conventions once, then use the table of contents as your map; the API version numbers next to names tell you what's new in Java 21. - For I/O, XML, and JDBC, run the companion code from horstmann.com/corejava rather than reading passively—these APIs reward experimentation. - If you don't write C++, skip the C++ notes; they're explicitly optional. 【Coverage Limits】 The excerpts cover the preface, table of contents, and the opening of the Streams chapter in detail, but only list chapter titles for later topics (I/O, XML, networking, JDBC, Swing, native methods). Specific techniques, examples, and Java 21 changes in those later chapters are not covered here.