mirror of
https://github.com/Fechin/reference.git
synced 2026-11-20 21:23:11 +03:00
734 lines
14 KiB
Markdown
734 lines
14 KiB
Markdown
---
|
|
title: Kotlin
|
|
date: 2023-02-26 16:24:31
|
|
background: bg-[#7954f6]
|
|
tags:
|
|
- Cross-platform
|
|
- Android
|
|
categories:
|
|
- Programming
|
|
intro: |
|
|
A quick reference cheatsheet for Kotlin that includes usage, examples, and more.
|
|
plugins:
|
|
- copyCode
|
|
---
|
|
|
|
## Introduction to Kotlin
|
|
|
|
### main()
|
|
|
|
```kotlin
|
|
fun main() {
|
|
println("Greetings, CheatSheets.zip!")
|
|
// Code goes here
|
|
}
|
|
```
|
|
|
|
The main() function is the starting point of every Kotlin program and must be included in the code before execution
|
|
|
|
### Print statement
|
|
|
|
```kotlin
|
|
println("Greetings, earthling!")
|
|
print("Take me to ")
|
|
print("your leader.")
|
|
|
|
/*
|
|
Print:
|
|
Greetings, earthling!
|
|
Take me to your leader.
|
|
*/
|
|
```
|
|
|
|
### Notes
|
|
|
|
```kotlin
|
|
// this is a single line comment
|
|
|
|
/*
|
|
this
|
|
note
|
|
for
|
|
many
|
|
*/
|
|
```
|
|
|
|
### Execution order
|
|
|
|
```kotlin
|
|
fun main() {
|
|
println("I will be printed first.")
|
|
println("I will be printed second.")
|
|
println("I will be printed third.")
|
|
}
|
|
```
|
|
|
|
## Data Types and Variables
|
|
|
|
### Mutable variables
|
|
|
|
```kotlin
|
|
var age = 25
|
|
age = 26
|
|
```
|
|
|
|
### Immutable variables
|
|
|
|
```kotlin
|
|
val goldenRatio = 1.618
|
|
```
|
|
|
|
### Type inference
|
|
|
|
```kotlin
|
|
// The following variables are assigned a literal value inside double quotes
|
|
// so the inferred type is String
|
|
|
|
var color = "Purple"
|
|
```
|
|
|
|
### String concatenation
|
|
|
|
```kotlin
|
|
var streetAddress = "123 Main St."
|
|
var cityState = "Brooklyn, NY"
|
|
|
|
println(streetAddress + " " + cityState)
|
|
// Print: 123 Main St. Brooklyn, NY
|
|
```
|
|
|
|
### String Templates
|
|
|
|
```kotlin
|
|
var address = "123 Main St."
|
|
println("The address is $address")
|
|
// prints: The address is 123 Main St.
|
|
```
|
|
|
|
### Built-in Properties and Functions
|
|
|
|
```kotlin
|
|
var monument = "the Statue of Liberty"
|
|
|
|
println(monument. capitalize())
|
|
// print: The Statue of Liberty
|
|
println(monument. length)
|
|
// print: 21
|
|
```
|
|
|
|
### Character escape {.row-span-2}
|
|
|
|
```kotlin {.wrap}
|
|
print("\"Excellent!\" I cried. \"Elementary,\" said he.")
|
|
|
|
// Print: "Excellent!" I cried. "Elementary," said he.
|
|
```
|
|
|
|
- `\n` insert new line
|
|
- `\t` inserts a tab
|
|
- `\r` inserts carriage return
|
|
- `\'` inserts a single quote
|
|
- `\"` inserts a double quote
|
|
- `\\` inserts a backslash
|
|
- `\$` inserts a dollar sign
|
|
|
|
### Arithmetic Operators
|
|
|
|
```kotlin
|
|
5 + 7 // 12
|
|
9 -2 // 7
|
|
8 *4 // 32
|
|
25 /5 // 5
|
|
31 % 2 // 1
|
|
```
|
|
|
|
`+` addition, `-` subtraction, `*` multiplication, `/` division, and `%` modulus
|
|
|
|
### Order of operations
|
|
|
|
```kotlin
|
|
5 + 8 *2 /4 -3 // 6
|
|
3 + (4 + 4) /2 // 7
|
|
4 *2 + 1 *7 // 15
|
|
3 + 18 /2 *1 // 12
|
|
6 -3 % 2 + 2 // 7
|
|
```
|
|
|
|
### Enhanced assignment operator
|
|
|
|
```kotlin
|
|
var batteryPercentage = 80
|
|
|
|
// long syntax
|
|
batteryPercentage = batteryPercentage + 10
|
|
|
|
// short syntax with augmented assignment operator
|
|
batteryPercentage += 10
|
|
```
|
|
|
|
### Increment and decrement operators
|
|
|
|
```kotlin
|
|
var year = 2019
|
|
year++ // 2020
|
|
year-- // 2019
|
|
```
|
|
|
|
### Math library
|
|
|
|
```kotlin
|
|
Math.pow(2.0, 3.0) // 8.0
|
|
Math.min(6, 9) // 6
|
|
Math.max(10, 12) // 12
|
|
Math. round(13.7) // 14
|
|
```
|
|
|
|
## Conditional Expression
|
|
|
|
### If expression
|
|
|
|
```kotlin
|
|
var morning = true
|
|
|
|
if (morning) {
|
|
println("Rise and shine!")
|
|
}
|
|
// Print: Rise and shine!
|
|
```
|
|
|
|
### Else-expression
|
|
|
|
```kotlin
|
|
var rained = false
|
|
|
|
if (rained) {
|
|
println("No need to water the plants today.")
|
|
} else {
|
|
println("The plant needs to be watered!")
|
|
}
|
|
// print: The plant needs watering!
|
|
```
|
|
|
|
### Else-If expressions
|
|
|
|
```kotlin
|
|
var age = 65
|
|
|
|
if (age < 18 ) {
|
|
println("You are considered a minor")
|
|
} else if (age < 60) {
|
|
println("You are considered an adult")
|
|
} else {
|
|
println("You are considered senior")
|
|
}
|
|
|
|
// print: you are considered senior
|
|
```
|
|
|
|
### Comparison Operators
|
|
|
|
```kotlin
|
|
var myAge = 19
|
|
var sisterAge = 11
|
|
var cousinAge = 11
|
|
|
|
myAge > sisterAge // true
|
|
myAge < cousinAge // false
|
|
myAge >= cousinAge // true
|
|
myAge <= sisterAge // false
|
|
```
|
|
|
|
### Logical Operators
|
|
|
|
```kotlin
|
|
var humid = true
|
|
var raining = true
|
|
var jacket = false
|
|
|
|
println(!humid)
|
|
// print: false
|
|
println(jacket && raining)
|
|
// print: true
|
|
println(humid || raining)
|
|
// print: true
|
|
```
|
|
|
|
### AND operator: &&
|
|
|
|
```kotlin
|
|
var humid = true
|
|
var raining = true
|
|
var shorts = false
|
|
var sunny = false
|
|
|
|
// true AND true
|
|
println(humid && raining) // true
|
|
// true AND false
|
|
println(humid && shorts) // false
|
|
// false AND true
|
|
println(sunny && raining) // false
|
|
// false AND false
|
|
println(shorts && sunny) // false
|
|
```
|
|
|
|
### Or operator:||
|
|
|
|
```kotlin
|
|
var late = true
|
|
var skipBreakfast = true
|
|
var underslept = false
|
|
var checkEmails = false
|
|
|
|
// true OR true
|
|
println(skipBreakfast || late) // true
|
|
// true OR false
|
|
println(late || checkEmails) // true
|
|
// false OR true
|
|
println(underslept || late) // true
|
|
// false OR false
|
|
println(checkEmails || underslept) // false
|
|
```
|
|
|
|
### NOT operator
|
|
|
|
```kotlin
|
|
var hungry = true
|
|
var full = false
|
|
|
|
println(!hungry) // false
|
|
println(!full) // true
|
|
```
|
|
|
|
### Evaluation order
|
|
|
|
```kotlin
|
|
!true && (false || true) // false
|
|
/*
|
|
(false || true) is evaluated first to return true.
|
|
Then, evaluate !true && true and return the final result false
|
|
*/
|
|
|
|
!false && true || false // true
|
|
/*
|
|
!false is evaluated first to return true.
|
|
Then true && true is evaluated, returning true.
|
|
then, true || evaluates to false and eventually returns true
|
|
*/
|
|
```
|
|
|
|
### Nested conditions
|
|
|
|
```kotlin
|
|
var studied = true
|
|
var wellRested = true
|
|
|
|
if (wellRested) {
|
|
println("Good luck today!")
|
|
if (studied) {
|
|
println("You should prepare for the exam!")
|
|
} else {
|
|
println("Spend a few hours studying before the exam!")
|
|
}
|
|
}
|
|
|
|
// Print: Good luck today!
|
|
// print: You should be ready for the exam!
|
|
```
|
|
|
|
### When expression
|
|
|
|
```kotlin
|
|
var grade = "A"
|
|
|
|
when (grade) {
|
|
"A" -> println("Great job!")
|
|
"B" -> println("Great job!")
|
|
"C" -> println("You passed!")
|
|
else -> println("Close! Be sure to prepare more next time!")
|
|
}
|
|
// print: Great job!
|
|
```
|
|
|
|
### Range operator
|
|
|
|
```kotlin {.wrap}
|
|
var height = 46 // inches
|
|
|
|
if (height in 1..53) {
|
|
println("Sorry, you must be at least 54 inches to ride the coaster")
|
|
}
|
|
// Prints: Sorry, you must be at least 54 inches to ride the roller coaster
|
|
```
|
|
|
|
### Equality Operators
|
|
|
|
```kotlin
|
|
var myAge = 22
|
|
var sisterAge = 21
|
|
|
|
myAge == sisterAge // false
|
|
myAge != sisterAge // true
|
|
```
|
|
|
|
## Null-Safety
|
|
|
|
### Nullable vs Not-Nullable
|
|
|
|
```kotlin
|
|
var a: String = "Kotlin" // a can never be null
|
|
a = null // compilation error
|
|
var b: String? = "Kotlin" // b can be null
|
|
b = null // ok
|
|
```
|
|
|
|
### Safe-Calls
|
|
|
|
```kotlin
|
|
val a = "Kotlin"
|
|
val b: String? = null
|
|
println(a.length) // can be called safely, because a is never null
|
|
println(b?.length) // b?.length returns the length of b, or null if b is null
|
|
println(a?.length) // Unnecessary safe call
|
|
```
|
|
|
|
### Chaining Safe-Calls
|
|
|
|
```kotlin
|
|
bob?.department?.head?.name // chain returns null if any property is null
|
|
```
|
|
|
|
### Elvis Operator
|
|
|
|
```kotlin
|
|
val l = b?.length ?: -1 // if b is null, return the default value -1
|
|
// equval to:
|
|
val l: Int = if (b != null) b.length else -1
|
|
```
|
|
|
|
### Not Null Assertion Operator
|
|
|
|
```kotlin
|
|
val l = b!!.length // throws a NullPointerException, if b is null
|
|
```
|
|
|
|
## Collections
|
|
|
|
### Immutable list
|
|
|
|
```kotlin {.wrap}
|
|
var programmingLanguages = listOf("C#", "Java", "Kotlin", "Ruby")
|
|
```
|
|
|
|
### Mutable List
|
|
|
|
```kotlin {.wrap}
|
|
var fruits = mutableListOf("Orange", "Apple", "Banana", "Mango")
|
|
```
|
|
|
|
### Access List
|
|
|
|
```kotlin {.wrap}
|
|
var cars = listOf("BMW", "Ferrari", "Volvo", "Tesla")
|
|
|
|
println(cars[2]) // Prints: Volvo
|
|
```
|
|
|
|
### Size Attribute
|
|
|
|
```kotlin {.wrap}
|
|
var worldContinents = listOf("Asia", "Africa", "North America", "South America", "Antarctica", "Europe", "Australia")
|
|
|
|
println(worldContinents.size) // Prints: 7
|
|
```
|
|
|
|
### List Manipulation {.row-span-2}
|
|
|
|
```kotlin {.wrap}
|
|
var seas = listOf("Black Sea", "Caribbean Sea", "North Sea")
|
|
println(seas. contains("North Sea")) // Prints: true
|
|
|
|
// The contains() function performs a read operation on any list and determines if the element exists
|
|
seas.add("Baltic Sea") // Error: cannot write to immutable list
|
|
// The add() function can only be called on mutable lists, so the code above throws an error
|
|
```
|
|
|
|
### Immutable Sets
|
|
|
|
```kotlin {.wrap}
|
|
var primaryColors = setOf("Red", "Blue", "Yellow")
|
|
```
|
|
|
|
### Mutable Sets
|
|
|
|
```kotlin {.wrap}
|
|
var womenInTech = mutableSetOf("Ada Lovelace", "Grace Hopper", "Radia Perlman", "Sister Mary Kenneth Keller")
|
|
```
|
|
|
|
### Access Collection Elements {.row-span-2}
|
|
|
|
```kotlin {.wrap}
|
|
var companies = setOf("Facebook", "Apple", "Netflix", "Google")
|
|
|
|
println(companies.elementAt(3))
|
|
// Prints: Google
|
|
println(companies.elementAt(4))
|
|
// Returns and Error
|
|
println(companies.elementAtOrNull(4))
|
|
// Prints: null
|
|
```
|
|
|
|
### Immutable Map
|
|
|
|
```kotlin {.wrap}
|
|
var averageTemp = mapOf("winter" to 35, "spring" to 60, "summer" to 85, "fall" to 55)
|
|
```
|
|
|
|
### Mutable Mapping
|
|
|
|
```kotlin {.wrap}
|
|
var europeanDomains = mutableMapOf("Germany" to "de", "Slovakia" to "sk", "Hungary" to "hu", "Norway" to "no")
|
|
```
|
|
|
|
### Retrieve map keys and values
|
|
|
|
```kotlin {.wrap}
|
|
var oscarWinners = mutableMapOf("Parasite" to "Bong Joon-ho", "Green Book" to "Jim Burke", "The Shape Of Water" to "Guillermo del Toro")
|
|
|
|
println(oscarWinners.keys)
|
|
// Prints: [Parasite, Green Book, The Shape Of Water]
|
|
|
|
println(oscarWinners.values)
|
|
// Prints: [Bong Joon-ho, Jim Burke, Guillermo del Toro]
|
|
println(oscarWinners["Parasite"])
|
|
// Prints: Bong Joon-ho
|
|
```
|
|
|
|
### Add and remove map entries
|
|
|
|
```kotlin {.wrap}
|
|
var worldCapitals = mutableMapOf("United States" to "Washington D.C.", "Germany" to "Berlin", "Mexico" to "Mexico City", "France" to "Paris")
|
|
|
|
worldCapitals.put("Brazil", "Brasilia")
|
|
println(worldCapitals)
|
|
// Prints: {United States=Washington D.C., Germany=Berlin, Mexico=Mexico City, France=Paris, Brazil=Brasilia}
|
|
|
|
worldCapitals.remove("Germany")
|
|
println(worldCapitals)
|
|
// Prints: {United States=Washington D.C., Mexico=Mexico City, France=Paris, Brazil=Brasilia}
|
|
```
|
|
|
|
## Function
|
|
|
|
### Function
|
|
|
|
```kotlin
|
|
fun greet() {
|
|
println("Hey there!")
|
|
}
|
|
|
|
fun main() {
|
|
//Function call
|
|
greet() //Prints: Hey there!
|
|
}
|
|
```
|
|
|
|
### Function Parameters
|
|
|
|
```kotlin {.wrap}
|
|
fun birthday(name: String, age: Int) {
|
|
println("Happy birthday $name! You turn $age today!")
|
|
}
|
|
|
|
fun main() {
|
|
birthday("Oscar", 26)
|
|
//Prints: Happy birthday Oscar! You turn 25 today!
|
|
birthday("Amarah", 30)
|
|
//Prints: Happy birthday Amarah! You turn 30 today!
|
|
}
|
|
```
|
|
|
|
### Default Parameters
|
|
|
|
```kotlin {.wrap}
|
|
fun favoriteLanguage(name: String, language: String = "Kotlin") {
|
|
println("Hello, $name. Your favorite programming language is $language")
|
|
}
|
|
|
|
fun main() {
|
|
favoriteLanguage("Manon")
|
|
//Prints: Hello, Manon. Your favorite programming language is Kotlin
|
|
|
|
favoriteLanguage("Lee", "Java")
|
|
//Prints: Hello, Lee. Your favorite programming language is Java
|
|
}
|
|
```
|
|
|
|
### Named Parameters
|
|
|
|
```kotlin {.wrap}
|
|
fun findMyAge(currentYear: Int, birthYear: Int) {
|
|
var myAge = currentYear -birthYear
|
|
println("I am $myAge years old.")
|
|
}
|
|
|
|
fun main() {
|
|
findMyAge(currentYear = 2020, birthYear = 1995)
|
|
//Prints: I am 25 years old.
|
|
findMyAge(birthYear = 1920, currentYear = 2020)
|
|
//Prints: I am 100 years old.
|
|
}
|
|
```
|
|
|
|
### Return Statement
|
|
|
|
```kotlin {.wrap}
|
|
//Return type is declared outside the parentheses
|
|
fun getArea(length: Int, width: Int): Int {
|
|
var area = length *width
|
|
|
|
//return statement
|
|
return area
|
|
}
|
|
|
|
fun main() {
|
|
var myArea = getArea(10, 8)
|
|
println("The area is $myArea.")
|
|
//Prints: The area is 80.
|
|
}
|
|
```
|
|
|
|
### Single expression function
|
|
|
|
```kotlin{.wrap}
|
|
fun fullName(firstName: String, lastName: String) = "$firstName $lastName"
|
|
|
|
fun main() {
|
|
println(fullName("Ariana", "Ortega"))
|
|
//Prints: Ariana Ortega
|
|
println(fullName("Kai", "Gittens"))
|
|
//Prints: Kai Gittens
|
|
}
|
|
```
|
|
|
|
### Function Literals
|
|
|
|
```kotlin{.wrap}
|
|
fun main() {
|
|
//Anonymous Function:
|
|
var getProduct = fun(num1: Int, num2: Int): Int {
|
|
return num1 *num2
|
|
}
|
|
println(getProduct(8, 3))
|
|
//Prints: 24
|
|
//Lambda Expression
|
|
var getDifference = { num1: Int, num2: Int -> num1 -num2 }
|
|
println(getDifference(10, 3))
|
|
//Prints: 7
|
|
}
|
|
```
|
|
|
|
## Class
|
|
|
|
### Class Example
|
|
|
|
```kotlin
|
|
//class with properties containing default values
|
|
class Student {
|
|
var name = "Lucia"
|
|
var semester = "Fall"
|
|
var gpa = 3.95
|
|
}
|
|
|
|
//shorthand syntax without class body
|
|
class Student
|
|
```
|
|
|
|
### Class Instance
|
|
|
|
```kotlin
|
|
// Class
|
|
class Student {
|
|
var name = "Lucia"
|
|
var semester = "Fall"
|
|
var gpa = 3.95
|
|
}
|
|
|
|
fun main() {
|
|
var student = Student()
|
|
// Instance
|
|
println(student.name)
|
|
// Prints: Lucia
|
|
println(student.semester)
|
|
// Prints: Fall
|
|
println(student.gpa)
|
|
// Prints: 3.95
|
|
}
|
|
```
|
|
|
|
### Primary Constructor
|
|
|
|
```kotlin {.wrap}
|
|
class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int)
|
|
|
|
fun main() {
|
|
var student = Student("Lucia", 3.95, "Fall", 2022)
|
|
println(student.name)
|
|
//Prints: Lucia
|
|
println(student.gpa)
|
|
//Prints: 3.95
|
|
println(student.semester)
|
|
//Prints: Fall
|
|
println(student.estimatedGraduationYear)
|
|
//Prints: 2022
|
|
}
|
|
```
|
|
|
|
### Initialization Block
|
|
|
|
```kotlin {.wrap}
|
|
class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int) {
|
|
init {
|
|
println("$name has ${estimatedGraduationYear -2020} years left in college.")
|
|
}
|
|
}
|
|
|
|
fun main() {
|
|
var student = Student("Lucia", 3.95, "Fall", 2022)
|
|
//Prints: Lucia has 2 years left in college.
|
|
}
|
|
```
|
|
|
|
### Member Function {.col-span-2}
|
|
|
|
```kotlin {.wrap}
|
|
class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int) {
|
|
|
|
init {
|
|
println("$name has ${estimatedGraduationYear -2020} years left in college.")
|
|
}
|
|
|
|
//member function
|
|
fun calculateLetterGrade(): String {
|
|
return when {
|
|
gpa >= 3.0 -> "A"
|
|
gpa >= 2.7 -> "B"
|
|
gpa >= 1.7 -> "C"
|
|
gpa >= 1.0 -> "D"
|
|
else -> "E"
|
|
}
|
|
}
|
|
}
|
|
|
|
//When the instance is created and the function is called, the when expression will be executed and return the letter grade
|
|
fun main() {
|
|
var student = Student("Lucia", 3.95, "Fall", 2022)
|
|
//Prints: Lucia has 2 years left in college.
|
|
println("${student.name}'s letter grade is ${student.calculateLetterGrade()}.")
|
|
//Prints: Lucia's letter grade is A.
|
|
}
|
|
```
|
|
|
|
## See Also
|
|
|
|
- [Kotlin Language Official Documentation](https://kotlinlang.org/) _(kotlinlang.org)_
|