Cheat Sheet: Kotlin — Backend Web, Spring Boot, and Android Development¶

// Variables
val x: Int = 42          // immutable (val = final in Java)
var count = 0            // mutable; type inferred
const val PI = 3.14159   // compile-time constant (top-level or companion object)

// Functions
fun greet(name: String): String = "Hello, $name!"   // single-expression

fun add(a: Int, b: Int = 0): Int {                   // default parameter
    return a + b
}

add(1)          // b defaults to 0
add(b = 2, a = 1)  // named arguments

// Classes
class Person(val name: String, var age: Int)         // primary constructor

data class Point(val x: Double, val y: Double)       // data class

class Rectangle(val width: Double, val height: Double) {
    val area: Double get() = width * height           // computed property
}

// Sealed class
sealed class Shape
data class Circle(val radius: Double) : Shape()
data class Rect(val w: Double, val h: Double) : Shape()

// When expression (exhaustive on sealed)
fun area(shape: Shape) = when (shape) {
    is Circle -> Math.PI * shape.radius * shape.radius
    is Rect   -> shape.w * shape.h
}

// Companion object (replaces Java static)
class Config {
    companion object {
        const val DEFAULT_TIMEOUT = 30
        fun load() = Config()
    }
}

// Extension function
fun String.wordCount(): Int = this.split(" ").size

// Object (singleton)
object Logger {
    fun log(msg: String) = println("[LOG] $msg")
}

val s: String? = null      // nullable type

// Safe call — returns null instead of throwing
val len = s?.length         // Int?

// Elvis operator — provide a default
val len2 = s?.length ?: 0  // Int (0 if s is null)

// Non-null assertion — throws NullPointerException if null (avoid!)
val len3 = s!!.length       // throws if s is null

// Safe cast — returns null if cast fails
val n: Int? = someValue as? Int

// Let — run a block only if non-null
s?.let { str ->
    println("String is: $str")
}

// Null check with smart cast
if (s != null) {
    println(s.length)  // s is smart-cast to String here
}

// Elvis with early return (common idiom)
fun process(input: String?) {
    val safe = input ?: return  // return early if null
    println(safe.length)
}

// Immutable (read-only view)
val list: List<Int> = listOf(1, 2, 3)
val map: Map<String, Int> = mapOf("a" to 1, "b" to 2)
val set: Set<String> = setOf("x", "y")

// Mutable
val mList: MutableList<Int> = mutableListOf(1, 2, 3)
mList.add(4)

// Common transformations (all return new collections)
list.map { it * 2 }                    // [2, 4, 6]
list.filter { it > 1 }                 // [2, 3]
list.reduce { acc, n -> acc + n }      // 6
list.fold(10) { acc, n -> acc + n }    // 16
list.flatMap { listOf(it, it * 10) }   // [1, 10, 2, 20, 3, 30]
list.groupBy { if (it % 2 == 0) "even" else "odd" }
list.sortedBy { it }
list.any { it > 2 }                    // true
list.all { it > 0 }                    // true
list.none { it < 0 }                   // true
list.first { it > 1 }                  // 2
list.firstOrNull { it > 10 }           // null (not found)
list.sumOf { it }                      // 6
list.maxOrNull()                       // 3

// Launch a fire-and-forget coroutine
scope.launch {
    doWork()
}

// Launch and get a result
val deferred: Deferred<String> = scope.async {
    fetchData()
}
val result = deferred.await()

// Suspend function
suspend fun fetchUser(id: Long): User {
    delay(100)                     // non-blocking sleep
    return api.getUser(id)
}

// Run blocking (for tests or main functions)
fun main() = runBlocking {
    val user = fetchUser(1)
    println(user)
}

// Flow — cold asynchronous stream
fun numbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)
        emit(i)
    }
}
// Collect a flow
numbers().collect { n -> println(n) }

// StateFlow — hot flow for state (Android ViewModels)
private val _uiState = MutableStateFlow(UiState.Loading)
val uiState: StateFlow<UiState> = _uiState.asStateFlow()

// Structured concurrency
coroutineScope {                     // waits for all children
    val a = async { computeA() }
    val b = async { computeB() }
    println(a.await() + b.await())
}

// Dispatchers
Dispatchers.Main      // Android main thread
Dispatchers.IO        // I/O-optimized thread pool
Dispatchers.Default   // CPU-intensive work

// build.gradle.kts — basic Spring Boot + Kotlin project
plugins {
    kotlin("jvm") version "2.0.0"
    kotlin("plugin.spring") version "2.0.0"
    id("org.springframework.boot") version "3.3.0"
    id("io.spring.dependency-management") version "1.1.5"
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

tasks.withType<Test> {
    useJUnitPlatform()    // required for JUnit 5
}

// Kotlin compiler options
tasks.withType<KotlinCompile> {
    compilerOptions {
        freeCompilerArgs.addAll("-Xjsr305=strict")   // strict null checks for JSR-305
        jvmTarget.set(JvmTarget.JVM_21)
    }
}

// Composable function — the building block of Compose UI
@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

// State in Compose
var count by remember { mutableStateOf(0) }
// or in a ViewModel:
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count.asStateFlow()

// Collect StateFlow in Compose
val count by viewModel.count.collectAsStateWithLifecycle()

// Navigation
val navController = rememberNavController()
NavHost(navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composable("detail/{id}") { backStackEntry ->
        DetailScreen(backStackEntry.arguments?.getString("id"))
    }
}
navController.navigate("detail/42")

// Hilt injection in ViewModel
@HiltViewModel
class MyViewModel @Inject constructor(
    private val repository: MyRepository
) : ViewModel()

// Room entity + DAO
@Entity(tableName = "users")
data class UserEntity(@PrimaryKey val id: Long, val name: String)

@Dao
interface UserDao {
    @Query("SELECT * FROM users") fun getAll(): Flow<List<UserEntity>>
    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun insert(user: UserEntity)
}