Core Java, Volume II Advanced Features (Oracle Press for Java), 14th Edition (Cay Horstmann) (Z-Library)

# Core Java, Volume II: Advanced Features — Reading Guide ## 【One-Line Pitch】 The definitive advanced Java reference for experienced programmers, covering the Stream API, I/O, databases, security, GUI development, and foreign function interfaces—updated through Java 25. If you've mastered core language syntax and now need to build production-grade Java applications, this is your practical handbook. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces the book's scope and audience—programmers with solid experience in another language who need Java's advanced libraries. The preface and table of contents map out the full journey: streams, I/O, XML, networking, databases, internationalization, security, GUI, and foreign functions. - **Early (~9%–25%)**: Dives into the Stream API (Chapter 1), teaching the "what, not how" paradigm for data processing with filter, map, flatMap, collectors, and parallel streams. Then covers comprehensive I/O handling—byte streams, character encodings, file operations, memory-mapped files, and object serialization—followed by XML processing, networking, and database connectivity via JDBC. - **Early (~25%–34%)**: Continues with the Date and Time API, internationalization (locales, number formats, resource bundles), the Compiler API, scripting integration, and a full security chapter covering class loaders, authentication (JAAS), digital signatures, and encryption (AES/RSA). - **Middle (~34%–47%)**: Transitions into GUI programming—first with foundational AWT concepts (frames, event handling, 2D shapes), then the comprehensive Swing toolkit covering layout managers, text components, menus, and advanced components like trees and tables. The chapter tour notes that GUI work is now less central but still valuable for server-side image generation. - **Late (~47%–end)**: Covers the Java 2D API for graphics and special effects, then the Foreign Function & Memory API (Chapter 13) for calling native code—covering arenas, memory segments, callbacks, and variable handles. The book concludes with practical examples and companion code available online. ## 【Key Takeaways】 - **Streams shift from imperative loops to declarative "what, not how" processing** (Early): Instead of writing for-loops with explicit iteration order, you chain operations like `.filter()` and `.count()`. The library optimizes execution, and switching to `.parallelStream()` enables multi-core parallelism with minimal code change. - **The Optional type prevents null-pointer bugs by forcing explicit handling** (Early): Optional values must be consumed deliberately—via `orElse`, `ifPresent`, or `flatMap` composition—rather than silently dereferenced. The book warns against common anti-patterns like calling `get()` without checking `isPresent()`. - **Collectors provide powerful one-line data aggregation** (Early): Beyond simple `toList()`, collectors handle grouping, partitioning, and downstream operations—letting you build complex maps and summaries without manual loop logic. - **Java I/O is a layered system of streams, readers, and writers** (Early): Understanding the "stream zoo"—filtering streams that wrap other streams—lets you compose functionality like buffering, compression (ZIP), and character encoding conversion. The chapter emphasizes Unicode handling through reader/writer classes. - **Object serialization requires understanding its file format and security implications** (Early): Beyond basic `Serializable`, you need transient fields, custom `readObject`/`writeObject` methods, and versioning strategies. The book explicitly warns about deserialization security risks in modern Java. - **JDBC provides programmatic database access with transaction control** (Early): Managing connections, prepared statements, scrollable result sets, and batch updates are covered in depth. The chapter includes practical patterns for connection management in web and enterprise applications. - **Security is a multi-layered concern: class loaders, authentication, and cryptography** (Early): The security chapter walks through the class-loading process, JAAS login modules, message digests, password hashing, certificate signing, and both symmetric (AES) and public-key (RSA) encryption—with working examples. - **The Foreign Function & Memory API enables safe native interop** (Late): For calling OS APIs or battle-tested C libraries (e.g., machine learning), the FFM API provides arenas for memory management, memory segments for safe access, and callbacks—replacing the older, riskier JNI approach. ## 【Reading Tips】 - **Skim the chapter tours in the preface first** (~28%–34%): The author explicitly states chapters are independent—you can jump to whatever topic you need without reading sequentially. Use this to prioritize. - **Deep-read Chapter 1 (Streams) and Chapter 2 (I/O)**: These are foundational for modern Java development and appear in almost every real project. Work through the code examples—especially collectors and serialization—rather than just reading. - **Treat Chapters 10–12 (GUI) as reference material**: The author notes most programmers don't build Swing UIs anymore. Skim for concepts, but focus on the server-side image generation parts if you need them. - **Pay attention to "caution" and "preview feature" icons** (~38%): These flag security risks (especially around deserialization) and upcoming API changes. The version numbers after API names (e.g., `java.lang.IO 25`) help you know what's new. - **Download the companion code from horstmann.com/corejava**: The book references listings throughout (e.g., `CountLongWords.java`); having the code open while reading makes the examples far more concrete. ## 【Coverage Limits】 This guide synthesizes the book's structure and key themes from the table of contents, preface, and early chapter excerpts. Detailed technical content from later chapters (XML specifics, advanced Swing components, full FFM API usage) is summarized at the topic level rather than with code-level detail. ##