Kotlin Cookbook A Problem-Focused Approach (Ken Kousen)（Z-Library）

【One-Line Pitch】 A problem-first recipe collection for developers who already know how to program and want to use Kotlin productively—covering everything from build setup and null-safety to functional idioms, delegates, and Java interop. Best for working Java/Android developers who prefer targeted answers over a linear tutorial. 【Book Arc】 - **Opening (~0%–10%)**: Installation, build tooling, and project setup—how to get Kotlin running on the JVM, in Gradle (Groovy and Kotlin DSL), in Android projects, and even as a standalone native binary via GraalVM. - **Early (~10%–32%)**: Core language mechanics—null-safety and smart casts, default arguments and `@JvmOverloads`, the absence of primitive auto-promotion, explicit numeric conversions, and the basics of properties with custom getters/setters. - **Middle (~32%–48%)**: Object-oriented and functional foundations—data classes, `copy` semantics, destructuring, singletons via `object`, operator overloading, `lateinit` vs. `lazy`, and functional reductions like `fold`/`reduce` and tail recursion. - **Late (~48% onward)**: Collections and immutability, sequences, delegates, scope functions, extension functions, and concurrency—building toward practical library and framework use. - **Ending**: Applied recipes for Java interoperability, testing with JUnit 5, and framework-specific advice (Android, Spring), tying the language features back to real project contexts. 【Key Takeaways】 - **Setup is treated as a first-class problem** (Opening): recipes cover `kotlinc`/`kotlin` commands, Gradle plugin configuration, mixed Java/Kotlin source trees, and GraalVM native images—so you can get a working project before worrying about syntax. - **Kotlin's type system changes everyday coding habits** (Early): smart casts work only on stable `val` references, primitives don't auto-promote, and conversions are explicit (`toInt`, `toLong`), which forces more deliberate numeric code than Java. - **Default arguments replace many overloads** (Early): `@JvmOverloads` bridges Kotlin defaults to Java callers, and nullable/optional parameters belong at the end of signatures for positional calls. - **Data classes give you `equals`, `copy`, and destructuring—with caveats** (Middle): `copy` is shallow, and `==` vs. `===` distinguishes equivalence from reference identity, a distinction the book reinforces through `equals` overrides using safe casts and the Elvis operator. - **`lateinit` and `lazy` solve different problems** (Middle): `lateinit` applies to `var` and can be initialized externally; `lazy` applies to `val` and defers expensive initialization—choosing wrong leads to awkward workarounds. - **Singletons and operators are language-level, not patterns** (Middle): `object` declarations compile to a private-constructor singleton, and `operator` functions let you give types natural arithmetic and unary behavior. - **Functional style is woven throughout, not siloed** (Middle): `fold`/`reduce` for iterative algorithms, `tailrec` for stack-safe recursion (JVM-only, no `try/catch/finally`), and read-only collections via `listOf`/`setOf`/`mapOf`. - **The book is test-driven by design** (Early): recipes use JUnit 5 assertions as executable examples, so you can adapt them directly into your own test suites. 【Reading Tips】 - **Skim the setup chapter if your toolchain is already working**—return to it only for GraalVM or Android-specific Gradle configuration. - **Deep-read the null-safety, property, and data-class recipes** (Early–Middle); these are where Kotlin diverges most sharply from Java and where habits transfer poorly. - **Treat the functional chapter as a reference, not a tutorial**—`fold`, `reduce`, and `tailrec` are best consulted when you hit a concrete algorithmic problem. - **Watch the Java-interop recipes closely** if you maintain mixed codebases; `@JvmOverloads`, `@JvmStatic`, and similar annotations are easy to overlook. - **Use the tests as your takeaway**: each recipe's assertions show expected behavior, so copy them into a scratch project to verify your understanding. 【Coverage Limits】 The excerpts cover setup, core language mechanics, OOP/functional basics, and early collection material, but do not detail the later chapters on delegates, scope functions, coroutines, or the Android/Spring framework recipes. This guide reflects only what the sampled chunks show.