1
2
3
4
fun main() {
    println("Hello, Kotlin!")
}

1
2
3
4
5
6
// Single-line comment

/* 
   Multi-line 
   comment 
*/

/**
 * KDoc documentation comment
 * Used for generating API documentation with Dokka
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Integers
val byte: Byte = 127       // 8-bit signed integer
val short: Short = 32767   // 16-bit signed integer
val int: Int = 2_147_483_647   // 32-bit signed integer
val long: Long = 9_223_372_036_854_775_807L  // 64-bit signed integer

// Unsigned Integers (stable since Kotlin 1.5)
val uByte: UByte = 255u
val uInt: UInt = 4_294_967_295u
val uLong: ULong = 18_446_744_073_709_551_615uL

// Floating Point
val float: Float = 3.14f   // 32-bit floating point
val double: Double = 3.14159  // 64-bit floating point

// Boolean
val bool: Boolean = true

// Character
val char: Char = 'A'

// String
val str: String = "Kotlin is awesome!"

// Multiline strings with trimIndent()
val multiline = """
    |Line 1
    |Line 2
""".trimMargin()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Nullable vs Non-Nullable Types
var nonNullableInt: Int = 42       // Cannot be null
var nullableString: String? = null  // Can be null

// Safe call operator
val length = nullableString?.length   // Returns null if nullableString is null

// Elvis operator (provide default value)
val safeLength = nullableString?.length ?: 0

// Not-null assertion (use sparingly)
val forcedLength = nullableString!!.length

// Safe casts
val asInt: Int? = "123" as? Int

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Immutable Lists
val immutableList: List<String> = listOf("Apple", "Banana", "Cherry")

// Mutable Lists
val mutableList: MutableList<String> = mutableListOf("Apple", "Banana")
mutableList.add("Cherry")

// Sets
val immutableSet: Set<Int> = setOf(1, 2, 3)
val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)

// Maps
val immutableMap: Map<String, Int> = mapOf("one" to 1, "two" to 2)
val mutableMap: MutableMap<String, Int> = mutableMapOf("one" to 1)
mutableMap["two"] = 2

// Arrays
val intArray: IntArray = intArrayOf(1, 2, 3)
val stringArray: Array<String> = arrayOf("a", "b", "c")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Immutable variable (read-only, like final in Java)
val pi: Double = 3.14159

// Compile-time constant (must be top-level or in object/companion object)
const val MAX_USERS = 100

// Mutable variable
var counter: Int = 0

// Type inference
val name = "Kotlin"  // Type is inferred as String
var age = 30         // Type is inferred as Int

// Late initialization (for non-null var properties)
lateinit var lateInitVar: String

// Lazy initialization (val only)
val expensiveValue: String by lazy { 
    // Computed only on first access
    "Expensive Computation"
}

1
2
3
4
5
6
val sum = 5 + 3       // Addition
val diff = 5 - 3      // Subtraction
val prod = 5 * 3      // Multiplication
val div = 6 / 3       // Division
val mod = 5 % 3       // Modulus

1
2
3
4
5
6
7
8
9
10
val a = 5
val b = 3
println(a == b)   // Structural equality (calls equals)
println(a != b)   // Structural inequality
println(a === b)  // Referential equality
println(a > b)    // Greater than
println(a < b)    // Less than
println(a >= b)   // Greater than or equal
println(a <= b)   // Less than or equal

1
2
3
4
5
6
7
val x = true
val y = false

println(x && y)   // Logical AND
println(x || y)   // Logical OR
println(!x)       // Logical NOT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// If-Else (an expression in Kotlin)
val max = if (x > y) x else y

// When Expression (advanced switch)
when (x) {
    1 -> println("x is 1")
    2, 3 -> println("x is 2 or 3")
    in 4..10 -> println("x is between 4 and 10")
    is Int -> println("x is an Int")
    else -> println("x is something else")
}

// When without argument (replaces if-else chains)
when {
    x < 0 -> println("negative")
    x == 0 -> println("zero")
    else -> println("positive")
}

// Guard conditions in when (stable since Kotlin 2.1)
when (animal) {
    is Cat if animal.mousesCaught > 0 -> println("Successful hunter")
    is Cat -> println("Just a cat")
    else -> println("Not a cat")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// For Loop with ranges
for (i in 1..5) println(i)        // 1, 2, 3, 4, 5 (closed range)
for (i in 1..<5) println(i)       // 1, 2, 3, 4 (open-ended range, since 1.9)
for (i in 5 downTo 1) println(i)  // 5..1
for (i in 1..10 step 2) println(i) // 1, 3, 5, 7, 9

// Iterating over collections
val fruits = listOf("Apple", "Banana", "Cherry")
for (fruit in fruits) {
    println(fruit)
}

// With index
for ((index, value) in fruits.withIndex()) {
    println("$index: $value")
}

// While Loop
var counter = 0
while (counter < 5) {
    println(counter)
    counter++
}

// Do-While Loop
do {
    println(counter)
    counter--
} while (counter > 0)

// Break and Continue
for (i in 1..10) {
    if (i == 5) continue
    if (i == 8) break
    println(i)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Function with return type
fun add(a: Int, b: Int): Int {
    return a + b
}

// Single-expression function
fun multiply(a: Int, b: Int) = a * b

// Function with default arguments
fun greet(name: String = "World") {
    println("Hello, $name!")
}

// Named Arguments
fun createUser(name: String, age: Int = 0, email: String = "") {
    // User creation logic
}
createUser(name = "John", email = "john@example.com")

// Vararg parameters
fun sumAll(vararg numbers: Int): Int = numbers.sum()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Lambda expression
val sum = { a: Int, b: Int -> a + b }
println(sum(3, 5))  // Prints 8

// Higher-order functions
val numbers = listOf(1, 2, 3, 4, 5)
val squared = numbers.map { it * it }
val filtered = numbers.filter { it % 2 == 0 }

// Function references
fun isOdd(x: Int) = x % 2 != 0
val odds = numbers.filter(::isOdd)

// Trailing lambda syntax
val result = numbers.fold(0) { acc, n -> acc + n }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Basic class with primary constructor
class Person(val name: String, var age: Int) {
    fun introduce() {
        println("Hi, I'm $name and I'm $age years old")
    }
}

// Data Class (automatic equals, hashCode, toString, copy, componentN)
data class User(val id: Int, val username: String)

// Inheritance (classes are final by default)
open class Animal {
    open fun makeSound() {
        println("Some sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Woof!")
    }
}

// Singletons via object declaration
object AppConfig {
    const val VERSION = "1.0"
}

// Sealed classes / interfaces (exhaustive when)
sealed interface Result<out T> {
    data class Success<T>(val value: T) : Result<T>
    data class Failure(val error: Throwable) : Result<Nothing>
}

// Value classes (stable since Kotlin 1.5) for zero-cost wrappers
@JvmInline
value class UserId(val value: Long)

// Data objects (stable since Kotlin 1.9) — singletons with proper toString
data object Loading

1
2
3
4
5
6
7
8
9
10
// Add methods to existing classes
fun String.removeWhitespace(): String =
    this.replace("\\s".toRegex(), "")

val cleanString = "Hello World".removeWhitespace()

// Extension property
val String.firstChar: Char?
    get() = if (isNotEmpty()) this[0] else null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Try-Catch (also an expression)
val result = try {
    10 / divisor
} catch (e: ArithmeticException) {
    println("Cannot divide by zero")
    0
} finally {
    println("Cleanup code")
}

// Precondition functions
fun validateAge(age: Int) {
    require(age >= 0) { "Age cannot be negative" }
    check(state.isReady) { "Not ready" }
}

// Result type for functional error handling
val parsed: Result<Int> = runCatching { "42".toInt() }
parsed.onSuccess { println(it) }.onFailure { println(it.message) }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.File
import kotlin.io.path.Path
import kotlin.io.path.readText
import kotlin.io.path.writeText

// Reading a file
val content = File("example.txt").readText()

// Writing to a file
File("output.txt").writeText("Hello, Kotlin!")

// Using Buffered Reader
File("example.txt").bufferedReader().use { reader ->
    val lines = reader.readLines()
}

// kotlin.io.path API (stable since Kotlin 1.5)
Path("example.txt").readText()
Path("output.txt").writeText("Hello, Kotlin!")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import kotlinx.coroutines.*

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

// Async/Await for parallel decomposition
suspend fun fetchUserData(): String = withContext(Dispatchers.IO) {
    delay(1000)
    "User Data"
}

suspend fun loadProfile() = coroutineScope {
    val user = async { fetchUserData() }
    val prefs = async { fetchPreferences() }
    user.await() to prefs.await()
}

// Structured concurrency with custom scope
class MyService : CoroutineScope by CoroutineScope(SupervisorJob() + Dispatchers.Default)

// Flows for reactive streams
import kotlinx.coroutines.flow.*

fun numbers(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

// StateFlow / SharedFlow are the recommended hot streams
val state = MutableStateFlow(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// JUnit 5 Example
import kotlin.test.Test
import kotlin.test.assertEquals

class CalculatorTest {
    @Test
    fun `addition works correctly`() {
        assertEquals(5, 2 + 3)
    }
}

// Coroutine testing with kotlinx-coroutines-test
import kotlinx.coroutines.test.runTest

@Test
fun coroutineTest() = runTest {
    val value = fetchUserData()
    assertEquals("User Data", value)
}