Kotlin Programming Language Cheatsheet

Kotlin has rapidly gained popularity as a versatile programming language since its introduction by JetBrains in 2011. Known for its conciseness, expressiveness, and interoperability with Java, Kotlin has become a favorite among developers for building modern, robust applications. Whether you’re a beginner or an experienced developer, having a handy cheat sheet can be a valuable resource to streamline your Kotlin coding experience. Let’s dive into the essentials with this Kotlin programming language cheat sheet.

1. Hello World!

fun main() {
    println("Hello, World!")
}

2. Variables and Data Types

// Immutable variable
val pi: Double = 3.14

// Mutable variable
var counter: Int = 0

// Type inference
val name = "Kotlin"

3. Functions

// Function with return type
fun add(a: Int, b: Int): Int {
    return a + b
}

// Single-expression function
fun multiply(x: Int, y: Int) = x * y

4. Control Flow

// If expression
val result = if (x > y) "x is greater" else "y is greater"

// When expression
when (day) {
    1 -> println("Monday")
    in 2..5 -> println("Weekday")
    else -> println("Weekend")
}

5. Collections

List

val numbers = listOf(1, 2, 3, 4, 5)

Set

val uniqueNumbers = setOf(1, 2, 3, 4, 5)

Map

val userMap = mapOf("name" to "John", "age" to 25)

6. Null Safety

// Nullable type
var nullableString: String? = null

// Safe call operator
val length = nullableString?.length

// Elvis operator
val nonNullLength = nullableString?.length ?: 0

7. Classes and Objects

// Class declaration
class Person(val name: String, val age: Int)

// Creating an object
val person = Person("Alice", 30)

8. Extensions

// Adding extension function to String class
fun String.addExclamation(): String {
    return "$this!"
}

// Using the extension function
val greeting = "Hello".addExclamation()

9. Coroutines

// Coroutine scope
import kotlinx.coroutines.*

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

10. Lambda Expressions

// Lambda expression
val sum: (Int, Int) -> Int = { a, b -> a + b }

// Higher-order function
fun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// Using the higher-order function
val result = operateOnNumbers(5, 3, sum)

This cheat sheet covers some fundamental aspects of Kotlin programming, serving as a quick reference for both beginners and experienced developers. Kotlin’s concise syntax, combined with powerful features like null safety and coroutines, makes it a compelling choice for a wide range of applications. As you explore Kotlin further, consider referring to this cheat sheet to enhance your productivity and streamline your coding journey. Happy coding in Kotlin!

Keep in mind that this is not an exhaustive list, and you may need to refer to the official Kotlin documentation for more in-depth information.