| layout | title | sidebar_link |
|---|---|---|
page |
Cheatsheet |
true |
What's important is not having each and every bit of syntax memorized, so feel free to use this a lot, print it out, bookmark it etc. It's also a good idea to inspire from this and/or make your own as a reference.
fun main() {
println("Hello, World!")
}The most basic program. Every program starts executing from main().
var <name_of_variable>: <Type> = <value>
var x: Int = 25
var displayNext: String = "Hello World"
var isSorted: Boolean = false;
var temperature = 24.32 // If you don't mention a type Kotlin can infer itThese are when you want to store data that you will expect changes more than once.
Type inference is fairly smart so almost all the time you can not mention the type and it will figure it out so put it in place where it matters.
val <name_of_variable>: <Type> = <value>
val name: String = "Harsh Deep"
val PI: Double = 3.14 // constants are conventionally upper case
val radius: Int = 10
val area = PI * radius // the guesses are fairly smartWhen you want to store something that will not change more than once. If it does use var.
Generally you'd want to use val as much as possible over var.
There are many different built in types for Data in Kotlin. The most important ones are
-
Int- whole numbers0,324123,42,-43,4234234 -
Double- numbers with decimal/fractional parts allowed0,42.125,-4236.3,-0.11233332 -
String- any type of text - "Random text", "Insurance rates go up 8%", "42.0", "25" -
Boolean- can be eithertrueorfalse. Useful in control flow likeif,when,for,whileetc.
Generally it's to<Type>() like toInt(), toDouble(), toString()
val x: Int = "42".toInt()
var y: Double = "21.5".toDouble()
val z: String = 32.toString()Most standard operations work with numeric types like Int and Double
val x: Int = 10
val y: Int = 3
val added = x + y // => 13
val subtracted = x - y // => 7
val multiplied = x * y // => 30
val integer_divided = x / y // => 3
val normal_divided = x.toDouble()/y // => 3.3333333333333335
val remainder = x % y // => 1Note that if we want normal division over integer division we have to convert one of them to a Double or some decimal type.
println("This prints out a whole line and to the next")
print("This only prints what's inside")
val name: String = "Harsh"
val age: Int = 19
val eyePower: Double = 0.103
// String interpolation
println("$name is ${age} years old with power $eyePower")Basically use print() to display, println() to print with a new line and string interpolation like${<variable name>} inside to print out values.
Most of the time if it's just a single variable name the {} are not requried and it's just $<variable name>
val score = 94.03
var grade = ""
if (score > 90) {
grade = "A"
} else if (score > 80) {
grade = "B"
} else {
grade = "C"
}
// or shorthand for just assignment only
val quickGrade = if (score > 90) "A" else if (score > 80) "B" else "C"Note as a block else is optional but when it's being used as an expression (ex. the quickGrade assignment above) then else has to be there.
If can be also used well with collections
val jvmLanguages = listOf("Java", "Kotlin", "Scala", "Clojure")
if ("Ruby" in jvmLanguages) {
println("Ruby is a JVM language")
}
val favLang = mapOf("Harsh" to "Ruby", "Varshini" to "Kotlin", "Vinayak" to "JavaScript")
if ("Astha" !in favLang) {
println("Astha has not decided what her favorite language is.")
}
if ("Java" !in favLang.values) {
println("No one likes Java :(")
}as well as ranges
val myAge = 20
if (myAge !in 13..19) {
println("I am no longer a teenager")
}For when there are more than two branches possible. This has some very powerful syntax better than C-like languages like switch
val age: Int = 19
val undergradAges: Array<Int> = arrayOf(18, 19, 20, 21, 22, 23, 24)
when (age) {
1 -> print("home")
2 -> print("day care")
3, 4, 5 -> print("pre-school")
in 6..17 -> print("school") // ranges
in undergradAges -> print("undergrad") // collections
else -> print("Invalid age")
}It works with single values, several values collected, ranges and collections as well as many more complex matchers.
repeat(3) { print("Loop $it") }
// => Loop 0 Loop 1 Loop 2var x = 0
while(x < 5) {
print("$x ")
x++
}
// => 0 1 2 3 4 For looping over anything that is Iterable like ranges, collections etc.
for (<variable name> in <iterable thing>) {
// body will run for each with <variable name> changing each time
}for (i in 0..5) print("$i ")
// => 0 1 2 3 4 5
for (i in 10 downto 1 step 2) print("$i ")
// => 10 8 6 4 2 val undergrad: Array<Int> = arrayOf(18, 19, 20, 21, 22)
for (age in undergradAges) {
print("$age ")
}
// => 18 19 20 21 22val cities = listOf("Bangalore", "London", "Champaign", "Urbana")
for (city in cities) {
println("$city ")
}
=> Bangalore London Champaign UrbanaHere it's slightly different because we can assign two variables, one for the key and the other for the value. Note the bracket around the variable part since we have more than one.
val studentGrades = mapOf("Alice" to 96.7,
"Greg" to 90.1,
"Jessica" to 89.7)
for ( (name, score) in studentGrades) {
println("$name got $score")
} Alice got 96.7
Greg got 90.1
Jessica got 89.7
A simple function with no parameters and no return
fun sayHello(): Unit {
println("Hello!")
}Unit indicated that there is no return, since it's optional we usually write it like
fun sayHello() {
println("Hello")
}Seperated by commas like functionName(name1: Type1, name2: Type2)
fun sayHello(from: String, to: String) {
println("$from says Hello to $to")
}For variable number of arguments (Varargs) we use the vararg keyword
fun printNumbers(vararg numbers: Int) {
for (number in numbers) {
print("$number ")
}
println()
}
fun main() {
printNumbers(1, 3, 5, 7, 9) // => 1 3 5 7 9
printNumbers() // =>
printNumbers(2) // => 2
}return brings the control back to the function that called it.
If you add a type then it gives back that value, like an output.
fun average(numbers: List<Double>): Double {
var sum: Double = 0.0
for (num in numbers) {
sum += num
}
var average = sum / numbers.size
return average
}Also called Generics and Parametric polymorphism
For parameterized types we want to write general functions over writing the same one again and again. Also called parametric polymorphism. We use <T> that denotes any generic type.
fun <T> getFirst(list: List<T>): T {
return list[0]
}
...
getFirst(listOf(1, 2, 3)) => 1
getFirst(listOf("Kotlin", "Java", "Scala") => Kotlinval function_name : Type = { arguments -> code body }Lambdas are like functions which can be assigned to variables, passed around functions and returned. It basically has a type (<list of types>) -><return type>
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }Kotlin is quite smart with type inference so this can also be
val sum = {x, y -> x + y}Lambdas can be used in higher order functions (functions that take in other functions as input)
val luckyNumbers = listOf(1, 2, 5, 25, 42)
luckyNumbers.map {it * it } // it is there if there is only one param
=> [1, 4, 25, 625, 1764]
luckyNumbers.filter {it % 2 == 0}
=> [2, 42]
luckyNumbers.fold(0) {acc, item -> acc + item}
=> 75Making one ourselves
fun nestedApply(input: Int, n: Int, fn: (Int) -> Int): Int {
var result: Int = input
for (i in 1..n) {
result = fn(result)
}
return result
}
...
nestedApply(10, 2) {it * it} // f(f(x)) where f(x) = x*x
// => 10000
nestedApply(10, 5) {it + 1} // f(f(f(f(f(x))))) where f(x) = x + 1
// => 15Classes wrap properties and behaviour. We use the class keyword
class Hero(val name: String, val type: String, var healthPoints: Int = 120) {
fun attacked(damage: Int) {
healthPoints -= damage
println("Oh no! $name got attacked with $damage with $healthPoints hp left")
}
fun healed(hp: Int) {
healthPoints += hp
println("Yay! $name got healed with $hp with $healthPoints hp now")
}
fun attack(anotherPlayer: Hero) {
println("$name attacks ${anotherPlayer.name}")
val damage = if (type == "Warrior") 50 else 30
anotherPlayer.attacked(damage)
}
fun heal(anotherPlayer: Hero) {
println("$name casts heal on ${anotherPlayer.name}")
val hp = if (type == "Mage") 40 else 10
anotherPlayer.healed(hp)
}
}val makes it read only, var means it will change. The variables can be accessed within the functions as is and other objects or outside the class you need the . dot notation. You also need the . notation to call functions outside the class.
To use objects of the class:
fun main() {
val harsh: Hero = Hero("Harsh", "Mage", 100)
val varshini = Hero("Varshini", "Warrior")
varshini.attack(harsh)
println()
println("Ooops, let me heal you")
varshini.heal(harsh)
println()
println("You aren't a mage so it wasn't that useful")
println("I'll do it myself")
harsh.heal(harsh)
}The data keyword before the class name sets up the standard utility functions (Plain Old Java Object) with ain class.
data class Hero(val name: String, val type: String, var healthPoints: Int) {
[...]
}Lets us do:
val hero1 = Hero("Harsh", "Mage", 100)
println(hero1) // get a nice print
// => Hero(name=Harsh, type=Mage, healthPoints=100)
println(hero1.healthPoints) // get values
// => 100
hero1.healthPoints = 80 // set values (var only)
println(hero1)
// => Hero(name=Harsh, type=Mage, healthPoints=80)
// Check equality
val hero2 = Hero("Varshini", "Warrior", 100)
println(hero1 == hero2) // => false
val hero3 = Hero("Harsh", "Mage", 80)
println(hero1 == hero3) // => true
// Destructure it
val (name, type, hp) = hero2
println(name) // => Varshini
// Copy
val mageVarshini = hero2.copy(type = "Mage")
println(mageVarshini)open class Person(val name: String,
var age: Int,) {
open fun display() {
println("Name: $name")
println("Age: $age")
}
}
class Student(name: String,
age: Int,
val mathScore: Double,
val scienceScore: Double): Person(name, age) {
override fun display() {
super.display()
println("Math Score: $mathScore")
println("Science Score: $scienceScore")
}
}
class Teacher(name: String,
age: Int,
var students: Collection<Student>): Person(name, age) {
override fun display() {
super.display()
println("Number of students: ${students.size}")
}
}One of the neatest things about Kotlin comes from it's null safe programming idioms. Unless you specifically allow Kotlin to, you will never encounter a NullPointerException as null checking becomes the compiler's job.
val name: String = null // this can't happen
var age = 19 // Inferred Int
age = null // this can't happenFor this we add ? at the end of the variable type to say, this can be of the type or null. This applies to function parameters, variable names, returns, class instance variables.
val name: String? = null
var age: Int? = 19
age = nullOr here is an example with functions
fun getNameIfAgeLegal(name: String, age: Int): String? {
if (age >= 18) {
return name
} else {
return null
}
}
val filteredName = getNameIfAgeLegal("Varshini", 20) // infer String?
println(filteredName) // => VarshiniKotlin also provides idiomatic ways to deal with functions that may return null. You'll often see this kind of code when interfacing with Java or Android libraries especially.
To call a method on something that results in a nullable type (ending with ?) instead of a normal method call . we use ?. which acts normally when the data is not null and when the data is null it just returns null instead of trying to call a function on null and creating a null pointer exception. The Kotlin compiler will make sure things propogate through the chain.
data class Person(var name: String, var leftEye: Eye?, var rightEye: Eye?)
data class Eye(var power: Double)
val me = Person("Harsh", Eye(0.1), Eye(-0.1))
println(me.leftEye?.power) // => 0.1
val her = Person("Varshini", Eye(-5.0), null) // arr
println(her.rightEye?.power) // => nullThe Elvis operator ?: can be used at the end of null chain calls when you want a default value in case you ended up with null.
val combinedPower = (her.leftEye?.power ?: 0.0) + (her.rightEye?.power ?: 0.0)
println(combinedPower) // => -5.0val name: String? = readLine()?.toString()
val age: Int? = readLine()?.toInt()
val eyePower: Double? = readLine()?.toDouble()
// Infers String?
val simple = readLine()readLine() gives us a line of input as a String, the ?. null safe calling takes care of input issues
import kotlinx.coroutines.*
fun main() = runBlocking {
val deferredFirst = async { getUser(1) }
val deferredSecond = async { getUser(2) }
println("Hello ${deferredFirst.await()}") // Hello Amirtha
println("Hello ${deferredSecond.await()}") // Hello Astha
}
suspend fun getUser(id: Int): String? {
val users = listOf("Harsh", "Amirtha", "Astha")
delay(200) // simulated load time
return users.elementAtOrNull(id);
}