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

【One-Line Pitch】 A topic-by-topic tour of the advanced Java standard library, from streams and I/O to networking, JDBC, and internationalization, written for developers who already know the language and want to use the platform's deeper APIs correctly. Best for intermediate Java programmers upgrading to modern versions or filling gaps left by introductory books. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book as deliberately modular—chapters can be read in any order—and opens with the stream library, teaching declarative data processing and parallel-friendly evaluation before anything else. - **Early (~10%–32%)**: Moves through I/O fundamentals (byte vs. character hierarchies, readers/writers, Unicode encodings, serialization, files, paths, memory-mapped channels), then regular expressions, then XML parsing and transformation (DOM, SAX, StAX, XSLT). - **Middle (~32%–55%)**: Shifts to networked and data-centric work: internet addresses, the modern HTTP client with asynchronous processing, mail, and a substantial JDBC section covering connections, statements, scrollable result sets, metadata, and connection pooling. - **Late (~55%–80%)**: Continues into the date/time library and internationalization, where the book's "big world" framing becomes concrete—locales, formatting, and resource handling for global software. - **Ending (~80%–100%)**: Closes with the remaining advanced platform topics (the excerpts do not cover these chapters in detail), reinforcing the reference-style structure rather than a single narrative climax. 【Key Takeaways】 - **Streams are the book's centerpiece and its modern idiom** (Opening): you declare *what* result you want, and the library chooses an evaluation strategy—especially valuable for multi-core parallelism. Learn `generate`, `iterate`, `lines`, `splitAsStream`, and `StreamSupport` for adapting non-stream sources. - **Optional is a design tool, not a null wrapper** (Opening): the author explicitly warns against `get`/`isPresent`/`isEmpty` habits and pushes `orElseThrow` only where emptiness is truly impossible. Treat an `Optional` variable as never-null. - **Collectors are customizable pipelines** (Opening): beyond built-in collectors, you can supply supplier, accumulator, combiner, and finisher functions—understanding this contract unlocks non-standard aggregations. - **Primitive streams avoid boxing overhead but require care** (Opening): `mapToInt`/`mapToLong`/`mapToDouble` and `boxed()` bridge object and primitive streams; the author flags the `Function.identity()` compile error as a common trap. - **I/O is two parallel hierarchies** (Early): bytes (`InputStream`/`OutputStream`) versus characters (`Reader`/`Writer`), with `Closeable`, `Flushable`, `Readable`, and `Appendable` as cross-cutting interfaces. Encoding properties (`stdin.encoding`, `stdout.encoding`, etc.) are version-sensitive and worth checking with `-XshowSettings:properties`. - **Serialization carries hidden fragility** (Early): object streams embed class, superclass, and field names; inner-class naming can differ across implementations, so static inner classes, enums, and records are the safe choices. - **XML has three parsing strategies with real trade-offs** (Early): DOM loads everything into a tree, SAX reports events without storing, and StAX offers an iterator over events—usually the most convenient. Choose based on document size and whether you need the full tree. - **JDBC fundamentals plus async HTTP round out the practical core** (Middle): scrollable result sets, metadata-driven table viewers, connection pooling, and `sendAsync` with `CompletableFuture` show how the library supports real applications, not just toy examples. 【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 and return later. - **Deep-read the stream and I/O chapters** if you write data-processing code; skim the XML/XSLT material unless you actually parse or transform XML. - **Watch the version markers**: the text repeatedly notes features added in specific Java releases (e.g., Java 18/25 encoding properties), so verify behavior against your target JDK. - **Type out the small examples** for collectors, serialization, and JDBC—these APIs have subtle contracts (combiner/finisher, class-name stability, cursor semantics) that reading alone won't internalize. - **Use the cautions as a checklist**: the author's "Caution" and "Tip" notes (backslash escaping in regex strings, `Function.identity()` boxing, inner-class serialization) are the highest-yield passages. 【Coverage Limits】 The excerpts sample roughly the first half of the book in depth (streams through JDBC) and only gesture at the later chapters on date/time, internationalization, and beyond; specific chapter titles, figures, and later-topic details are not fully covered here.