Fundamentals

Kotlin has two keywords for declaring a variable. val (value) is read-only: it is assigned once and can never point at something else. var (variable) can be reassigned. Idiomatic Kotlin uses val everywhere it can and reaches for var only when a value genuinely changes — a counter, a running total. Fewer things that change means fewer places a bug can hide.

fun main() {
    val name = "Asha"      // read-only
    var score = 10         // reassignable
    score = score + 5
    score += 5
    println("$name scored $score")
}

Asha scored 20

fun main() {
    val count = 1
    count = 2
    println(count)
}

Main.kt:3:5: error: 'val' cannot be reassigned.

fun main() {
    var count = 1
    count = 2
    println(count)
}

Every value in Kotlin has a type that is fixed at compile time. You rarely write it, because the compiler infers it from the initial value: 42 is an Int, 42L a Long, 3.14 a Double, 3.14f a Float, 'A' a Char. Write the type after a colon when you want to be explicit or when there is no initial value.

fun main() {
    val age = 30                  // Int
    val population = 8_100_000_000L // Long (underscores are ignored)
    val price = 19.99             // Double
    val ratio: Float = 0.5f
    val initial = 'K'             // Char
    val active = true             // Boolean
    val city: String = "Pune"

    println("$age $population $price $ratio $initial $active $city")
    println("Int max: ${Int.MAX_VALUE}")
    println("Long max: ${Long.MAX_VALUE}")
}

30 8100000000 19.99 0.5 K true Pune
Int max: 2147483647
Long max: 9223372036854775807

fun main() {
    val count: Int = "12"
    println(count)
}

Main.kt:2:22: error: initializer type mismatch: expected 'Int', actual 'String'.

fun main() {
    val count: Int = "12".toInt()
    println(count)
}

Strings are immutable: every function that "changes" a string returns a new one. String templates put values inside a string: $name for a plain variable, ${...} for any expression, such as a property, a function call or arithmetic. Raw strings in triple quotes keep newlines and backslashes as-is; trimIndent() removes the common leading indentation.

fun main() {
    val first = "Grace"
    val last = "Hopper"
    val full = "$first $last"

    println(full)
    println("Length: ${full.length}")
    println(full.uppercase())
    println(full.lowercase())
    println(full.substring(0, 5))
    println(full.contains("Hop"))
    println(full.replace("Grace", "G."))
    println("  padded  ".trim() + "|")
    println(full[0])

    val poem = """
        Roses are red,
        Kotlin is neat.
    """.trimIndent()
    println(poem)
}

Grace Hopper
Length: 12
GRACE HOPPER
grace hopper
Grace
true
G. Hopper
padded|
G
Roses are red,
Kotlin is neat.

Arithmetic works as you expect, with one trap: dividing two Ints gives an Int — the fraction is thrown away. Make one side a Double to get a decimal result. % is the remainder. Comparison operators return a Boolean, and &&, || and ! combine booleans with short-circuiting (the right side is skipped when the left already decides the answer).

fun main() {
    val a = 17
    val b = 5
    println(a + b)
    println(a - b)
    println(a * b)
    println(a / b)          // Int / Int -> Int
    println(a % b)          // remainder
    println(a / b.toDouble())

    var n = 1
    n++
    n *= 10
    println(n)

    println(a > b && b > 0)
    println(a < b || b == 5)
    println(!(a == b))
    println("kotlin" == "kot" + "lin")
}

22
12
85
3
2
3.4
20
true
true
true
true

readln() reads one line from standard input and returns it as a String (without the newline). It throws if input has ended; readlnOrNull() returns null instead. Input is always text — convert it to a number yourself. The example below was run with the two input lines shown under "stdin".

fun main() {
    print("Your name: ")
    val name = readln()
    print("Your age: ")
    val age = readln().toInt()
    println()
    println("Hi $name, next year you will be ${age + 1}.")
}

Your name: Your age: 
Hi Meera, next year you will be 25.

fun main() {
    // Several numbers on one line, separated by spaces
    val numbers = readln().split(" ").map { it.toInt() }
    println("Count: ${numbers.size}")
    println("Sum: ${numbers.sum()}")
    println("Max: ${numbers.max()}")
}

Count: 4
Sum: 22
Max: 9

Kotlin never converts between number types implicitly — not even from Int to Long, which Java does silently. You call a conversion function: toInt(), toLong(), toDouble(), toString(). Converting a String to a number can fail, so there are two versions: toInt() throws on bad input, toIntOrNull() returns null, which you then handle with ?: (the "Elvis" operator, Module 04).

fun main() {
    val small: Int = 42
    val big: Long = small.toLong()
    val d: Double = small.toDouble()
    println("$big $d")

    println(3.99.toInt())         // truncates toward zero
    println("123".toInt() + 1)
    println(65.toChar())
    println('A'.code)

    val inputs = listOf("7", "seven", "12")
    for (s in inputs) {
        val n = s.toIntOrNull() ?: 0
        println("'$s' -> $n")
    }
}

42 42.0
3
124
A
65
'7' -> 7
'seven' -> 0
'12' -> 12

fun main() {
    val small: Int = 42
    val big: Long = small
    println(big)
}

Main.kt:3:21: error: initializer type mismatch: expected 'Long', actual 'Int'.

fun main() {
    val small: Int = 42
    val big: Long = small.toLong()
    println(big)
}

fun main() {
    val input = "12a"
    val n = input.toInt()
    println(n + 1)
}

Exception in thread "main" java.lang.NumberFormatException: For input string: "12a"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
	at java.base/java.lang.Integer.parseInt(Integer.java:662)
	at java.base/java.lang.Integer.parseInt(Integer.java:778)
	at MainKt.main(Main.kt:3)

fun main() {
    val input = "12a"
    val n = input.toIntOrNull()
    if (n == null) println("not a number") else println(n + 1)
}

A range is a sequence of values between two ends. 1..5 includes both ends. 1 until 5 (or 1..<5) excludes the upper end — exactly the indexes of a 5-element list. step skips values and downTo counts backwards. in tests whether a value falls inside a range, and ranges work for Char too.

fun main() {
    println((1..5).toList())
    println((1 until 5).toList())
    println((1..<5).toList())
    println((0..10 step 3).toList())
    println((5 downTo 1).toList())
    println(('a'..'e').joinToString(""))

    val age = 17
    println(age in 13..19)
    println(age !in 0..12)
    println((1..100).sum())
}

[1, 2, 3, 4, 5]
[1, 2, 3, 4]
[1, 2, 3, 4]
[0, 3, 6, 9]
[5, 4, 3, 2, 1]
abcde
true
true
5050

val

A read-only variable: assigned once, cannot be reassigned.

var

A mutable variable that can be reassigned.

Type inference

The compiler working out a variable's type from its initial value.

String template

$name or ${expression} inside a string literal.

Raw string

A """triple-quoted""" string that keeps newlines and backslashes literally.

readln()

Reads one line of standard input as a String; throws at end of input.

toIntOrNull()

Parses a String to Int, returning null instead of throwing on bad input.

Range

a..b (inclusive) or a until b / a..