Kotlin in Action 2ed 2024 (Sebastian Aigner, Roman Elizarov etc.)（Z-Library）

【One-Line Pitch】 A thorough, Java-informed tour of Kotlin 2.0 that takes you from everyday syntax to coroutines and DSL design, written for developers who want to write idiomatic Kotlin on the JVM or Android rather than just transliterate Java. 【Book Arc】 - **Opening (~0%–10%)**: Frames Kotlin's value proposition — conciseness, null safety, Java interoperability, and tooling — and sets expectations for readers with Java or similar backgrounds. - **Early (~10%–30%)**: Core language fundamentals: functions, `val`/`var`, string templates, classes, `if`/`when` as expressions, smart casts, loops, and extension functions/properties for extending existing APIs. - **Early–Middle (~30%–45%)**: Object-oriented depth — visibility rules, inner vs. nested classes, constructors, interface properties, companion objects, object expressions, and how Kotlin declarations map to Java/bytecode. - **Middle (~45%–60%)**: Functional programming with lambdas: collection operations (`filter`, `map`, `reduce`, `fold`, `groupBy`, `chunked`, `windowed`), sequences for lazy evaluation, and scope functions like `apply` and `run`. - **Late (~60%–85%)**: Nullability in depth — safe calls, Elvis operator, `!!`, `let`, lateinit, nullable extensions, type-parameter nullability, and Java platform types. - **Ending (~85%–100%)**: Advanced abstractions and concurrency — building DSLs, structured concurrency, coroutines, and flows, with guidance on integrating Kotlin into existing Java projects. 【Key Takeaways】 - **Kotlin is designed for smooth Java interoperability** (Early): extension functions, visibility mapping, and bytecode correspondence let you adopt Kotlin incrementally without rewriting existing Java code. - **Null safety is a first-class language feature, not a library** (Late): safe calls, Elvis, `!!`, `let`, and lateinit give you a graduated toolkit, while platform types expose the boundary where Java's nullability is unknown. - **Expressions replace statements wherever possible** (Early): `if`, `when`, and `try` return values, reducing boilerplate and intermediate variables compared to Java. - **Extension functions and properties extend any API without inheritance or wrappers** (Early): they work on JDK, Android, and third-party classes with no runtime overhead. - **Lambdas plus standard-library collection functions replace manual iteration** (Middle): `filter`/`map`/`fold`/`groupBy`/`chunked`/`windowed` cover most data-shaping needs, and sequences add laziness when intermediate collections would be wasteful. - **Scope functions like `apply`, `with`, and `run` shape initialization and configuration code** (Middle): `apply` in particular replaces Java-style builders for object setup. - **Coroutines and structured concurrency are the modern answer to concurrency** (Ending): lightweight coroutines, cancellation propagation, and cold/hot flows let you express concurrent work safely and at scale. - **Kotlin supports building high-level abstractions and DSLs** (Ending): the language's expressive features are aimed at domain-specific design, not just general application code. 【Reading Tips】 - **Skim the fundamentals if you already know Java**: the early chapters move fast and mostly map familiar concepts; slow down at extension functions, smart casts, and `when` since these change how you write daily code. - **Deep-read the nullability chapter**: it is the single biggest behavioral difference from Java and the source of most interop friction; pay special attention to platform types. - **Treat the collections/lambdas chapter as a reference**: bookmark the function families (`associate`, `groupBy`, `chunked`, `windowed`, `zip`, `flatten`, `flatMap`) and return when refactoring loops. - **Do not skip the coroutines section even if you are not writing concurrent code yet**: structured concurrency shapes how modern Kotlin codebases are organized. - **Keep the Java-interop material handy during migration**: the visibility and bytecode discussions explain surprises when mixing languages in one project. 【Coverage Limits】 The excerpts cover the book's structure, front matter, and selected sections on fundamentals, extensions, classes, lambdas, collections, nullability, and coroutines, but do not include full chapter text for DSL construction, flows, or Java integration specifics; details there are inferred from section titles and summaries.