Kotlin Learning repo ✨

This is my repository for learning Kotlin. I will try to push every piece of code that helps me learn Kotlin here. Apps I built using kotlin can be found here

References: Envato tuts+ | Getting started doc on android | Kotlin Docs

Variable vs Value

var nameofvar:Int =5 // Variable declaration syntax
val nameofval:Int =5 // Value declaration syntax
// Variables can be changed while values can not be

Ranges inside loop

for(i in 1..5){
  }
for(i in 1.rangeTo(5)){
  }
// above loops are in range 1 to 5
for(i in 10.downTo(1)){
  }
// the above loop ranges in decreasing order from 10 to 1
for(i in 1..10  step 2 ) // 1, 3, 5, 7, 9

Null Safety

Kotlin is a null safe language! It can not hold null values by default unless explicitly mentioned.

val x:Int = null //Throws an error
val x:Int ?= null //Suffixing ? to a type accepts null
// Since the '?' operator is used for specifying nullability,
// conditional operator does not exist in kotlin

Safe call

val b: String? = null
println(b?.length)// '?.' safe call operator

This returns b.length if b is not null, and null otherwise. The type of this expression is Int?.

Elvis

When we have a nullable reference b, we can say "if b is not null, use it, otherwise use some non-null value":

val l = b?.length ?: -1 // '?:' elvis operator
// here b will use -1 if it is null

Not-null assertion (!!)

val l = b!!.length

The not-null assertion operator (!!) converts any value to a non-null type and throws a NPE if the value is null. 😈

Collections of Nullable Type

If you have a collection of elements of a nullable type and want to filter non-null elements, you can do so by using filterNotNull:

val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull() //1,2,4

Conditions

if...else

Unlike other languages, the if..else statement in Kotlinhas the ability to assign a variable from the returned value of the if..else statement.

val number = 13
val result = if (number % 2 == 0) {
print("$number is divisible by 2")
} else {
print("$number is not divisible by 2")// 13 is not divisible by 2
} // result has the value "13 is not divisible by 2"

when

Alternate of switch in other languages.

val number = 2
when (number) { 
    1 -> println("number is 1")
    2 -> { //enclosed in braces for multiline body
        println("number is 2") 
        println("it is an even number")
        //this will be executed
    }
    3,4 -> println("number is 3 OR 4") //values can also be combined
}

// when can also work without any argument like this
when {
number == 1 -> println("it is one")
number == 2 -> println("it is two")
}

Functions

Above function can also be written as

fun add(a: Int, b: Int) = a + b

Extension Functions

• An extension function is a member function of a class that is defined outside the class.

fun String.removeFirstLastChar(): String = this.substring(1, this.length - 1)

Collections

Representation of parent classes of different collections in kotlin (Click on image for docs)

Arrays (Mutable)

var myArray = arrayOf(4, 5, 7, 3, "Chike", false) //Mixed array with different data types
var myArray = arrayOf<Int>(4, 5, 7, 3) //Contains only int as explicitly mentioned. Can also use intArrayOf()

Array() constructor (mind the uppercase 'A')

var newArray = Array (10,{i->i*2}) //Contains 0,2,4,6,..16,18
// Array(<size_of_array>,lambda_def)

Lists

By default lists are immutable

var numbers: List<Int> = listOf(1, 2, 3, 4, 5)
var names: List<String> = listOf("Chike", "Nnamdi", "Mgbemena")
var mix = listOf(1,2,3,4,"Ash",true)
val emptyList: List<String> = emptyList<String>() //Creates an empty list
val nonNullsList: List<String> = listOfNotNull(2, 45, 2, null, 5, null) //Creates a list excluding null elements

For mutable list

var mutableNames1 = names.toMutableList() //Converts immutable list to mutable
var newlist:List<Int> = mutableListOf(1,2,3)

Member functions

println(list.size) // returns size of list
println(list.get(0)) // returns element at 0 index in the list
println(list.indexOf(3)) // returns index of 3 in list
println(list.contains(3)) // returns boolean for presence of 3 in list

Functions for mutable lists

• set(index: Int, element: E): substitutes an element in the list with another element. This returns the element previously at the specified position.
• add(index: Int, element: E): inserts an element at the specified index.
• removeAt(index: Int): gets rid of the element at a particular index.
• remove(element: E): deletes the element specified.

val mutableListFood:  MutableList<String>  = mutableListOf<String>("Rice & stew",  "Jollof rice",  "Eba & Egusi",  "Fried rice")
mutableListFood.remove("Fried rice")
mutableListFood.removeAt(0)
mutableListFood.set(0,"Beans")
mutableListFood.add(1,"Bread & tea")

Sets

• Immutable by default, doesn't have repititive elements

  val mixedTypesSet = setOf(2, 4.454, "how", "far", 'c', 2)
  print(mixedTypesSet) // 2, 4.454, how, far, c

Function	Returned object type	Additional Remarks
hashSetOf()	Java HashSet collection	Becomes mutable, stored in a hash table
sortedSetOf()	Java TreeSet collection	Becomes sorted
linkedSetOf()	Java LinkedHashSet type	Maintains a linked list of the entries in the set, in the order in which they were inserted
mutableSetOf()	Kotlin MutableSet interface (Java LinkedHashSet type)	The MutableSet interface extends both the MutableCollection and the Set interfaces

Maps

• Maps are lists of pairs (keys and values: usually denoted as key to value)

var n = mapOf(1 to "One", 2 to "Two", 3 to 3.33) //immutable
println(n)//{1=One, 2=Two, 3=3.33}
for((a,b) in n){
      println("$a is $b")
  }
/*
1 is One
2 is Two
3 is 3.33
*/

val newmap: MutableMap<String, String> = mutableMapOf("A" to "Alpha", "B" to "Beta", "G" to "Gamma")
println("Greek is ${newmap.values}") // Greek is [Alpha, Beta, Gamma]
println("Letters are ${newmap.keys}") // Letters are [A, B, G]
//member functions
newmap.put("M","mu") // Adds a key,value pair
newmap.remove("G") // Removes at specified key

• Maps don't extend any interface unlike the other collections above
• Using hashMapOf() function returns a Java HashMap type that is mutable
• Using the linkedHashMap() function returns a Java LinkedHashMap type that is mutable and maintains a linked list of the entries in the map in the order in which they were inserted
• Using sortedMapOf() function returns a Java SortedMap type that maintains the entries in ascending key order

Collections Operation Functions

val a = mutableListOf(1,2,3,8,9,4,5)
  println(a.first()) // Returns the first value of the collection
  println(a.last()) // Returns the last value of the collection
  println(a.max()) // Returns the maximum value of the collection
  println(a.drop(3)) // Drops the first n elements (3 here) of the collections and returns a colection of the rest
  println(a.plus(9)) //Returns a new collection including n 
  println(a.minus(9)) //Returns a new collection excluding all instances of n 
  println(a.average()) //Returns the average value of the collection

//OUTPUT
1 
5 
9 
[8, 9, 4, 5] 
[1, 2, 3, 8, 9, 4, 5, 9] 
[1, 2, 3, 8, 4, 5] 
4.571428571428571