View on GitHub

kotlin-school

My very own tasteless way to learn kotlin

GitHub top language GitHub last commit

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

image

Above function can also be written as

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

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

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

  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

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