Audrey's Kotlin for Developers Cheatsheet

kotlin_for_devs_cheatsheet.md

Variables

Declare var for a mutable variable:

var name = "Mommy"
name = "Uma"

Declare val for a read-only constant:

val pi = 3.14

Increment and decrement operators:

var toyCount = 4
toyCount++
toyCount--

Double for decimal values:

var starValue: Double = 0.1

Boolean for true/false values:

var isPlaying = true

Data Types

val name: String = "Mommy"
val age: Int = 30
val height: Double = 5.5
val isPlaying: Boolean = true
val pi: Float = 3.14f

Comments

// This is a single-line comment

/*
This is a multi-line comment
*/

/**
 * This is a KDoc documentation comment
 */

Functions

fun greeting(): String {
    return "Hello!"
}

println(greeting())

Function with parameters and KDoc documentation:

fun add(a: Int, b: Int): Int {
    /**
     * Adds two numbers together.
     *
     * @param a The first number to add.
     * @param b The second number to add.
     * @return The sum of the two numbers.
     */
    return a + b
}

Single-Expression Functions

Return type can be inferred:

fun greeting() = "Hello!"

Default Parameter Values

Function with default parameter value:

fun greeting(name: String = "Mommy") = "Hello, $name!"

Named Arguments

Function with named arguments:

fun greeting(name: String, greeting: String) = "$greeting, $name!"

println(greeting(name = "Mommy", greeting = "Hello"))

When calling a function with named arguments, you can change the order of the arguments:

println(greeting(greeting = "Hello", name = "Mommy"))

Varargs

Function with varargs:

fun sum(vararg numbers: Int): Int {
    var total = 0
    for (number in numbers) {
        total += number
    }
    return total
}

println(sum(1,2,3))

The default function return type is Unit, which is equivalent to void in Java.

Lambdas and Higher-Order Functions

Function that takes a lambda as a parameter:

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val result = calculate(1, 2, ::sum)

You can call the same function using a lambda expression instead of a function reference:

val result = calculate(1, 2) { a, b -> a + b }

Function that returns a lambda:

fun operation(): (Int, Int) -> Int {
    return { a, b -> a + b }
}

val result = operation()(1, 2)

Classes

class Person(var name: String)

val person = Person("John")
person.name = "Daddy"

Inheritance

The open keyword is required to allow inheritance. By default, classes are final and cannot be inherited from.

open class Person(var name: String)

class Student(name: String, var grade: Int) : Person(name)

val student = Student("Daddy", 5)
student.name = "Uma"
student.grade = 6

Data Classes

A data class is a class that only holds data, and has no behavior.

data class Person(var name: String)

val person = Person("Mommy")
person.name = "Uma"

Collections

A List is an ordered collection of items.

val toys: List<String> = listOf("bear", "doll", "car")
val toyCount: Int = toys.size
val firstToy: String = toys[0]
val lastToy: String = toys.last()
val hasCar: Boolean = toys.contains("car")

val numbers = mutableListOf(1,2,3)
numbers.add(4)

A Set is an unordered collection of unique items.

val numsSet = setOf(1,2,3)
println(numsSet.contains(2))

A Map is a collection of key-value pairs.

val toys: Map<String, Int> = mapOf("bear" to 1, "doll" to 2, "car" to 3)
val toyCount: Int = toys.size
val bearCount: Int = toys["bear"] ?: 0
val hasCar: Boolean = toys.containsKey("car")

Ranges

val numbers = 1..10
val numbers = 1 until 10
val numbers = 10 downTo 1
val numbers = 1..10 step 2

Loops

for (i in 1..10) {
    println(i)
}

for (i in 10 downTo 1 step 2) {
    println(i)
}

val toys = listOf("bear", "doll", "car")
for (toy in toys) {
    println(toy)
}

val toys = mapOf("bear" to 1, "doll" to 2, "car" to 3)
for ((toy, count) in toys) {
    println("$toy: $count")
}

Conditionals

val age = 30
if (age < 18) {
    println("You are a child")
} else if (age < 65) {
    println("You are an adult")
} else {
    println("You are a senior")
}

Exceptions

fun divide(a: Int, b: Int): Int {
    if (b == 0) {
        throw IllegalArgumentException("Cannot divide by zero")
    }
    return a / b
}

try {
    divide(1, 0)
} catch (e: IllegalArgumentException) {
    println(e.message)
}

Control Flow

fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

val result = max(1, 2)

Null Safety

var name: String? = null
name = "John"

Extensions

fun String.initials(): String {
    return this.split(" ").map { it.first() }.joinToString("")
}

val name = "John Doe"
println(name.initials())

Generics

class Box<T>(t: T) {
    var value = t
}

val box = Box(1)

Coroutines

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

Android

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Resources

• Kotlin Koans
• Kotlin Playground
• Kotlin Reference
• Kotlin Standard Library

Credits

• This cheatsheet was inspired by Daniel Roy Greenfeld's Thoughts on Kotlin
• GitHub Copilot was used to generate some of the code snippets, which I then modified and checked for correctness