Part 3 — Lambda Expressions, Collection and Generics

5 min readMar 5, 2024

Kotlin Series

Lambda Expression Basics

Menjalankan lambda bisa menggunakan command run. Berikut contoh sederhananya

fun main(args: Array<String>) {
	run { println("I'm in a lambda")}
}

Berikut adalah contoh lain penggunaan lambda untuk mencari tahun terlama seorang employee bekerja.

fun main(args: Array<String>) {
  val employees = listOf(
    Employee("John", "Smith", 2012),
    Employee("Jane", "Wilson", 2015),
    Employee("Mary", "Johnson", 2010),
    Employee("Mike", "Jones", 2002)
  )
  println(employees.minBy{ it.startYear }	
  // atau println(employees.minBy(Employee::startYear))} -> namanya member reference

  data class Employee(val firstName: String, val lastName: String, val startYear: Int
)

Member reference juga bisa digunakan untuk eksekusi function seperti

fun main(args: Array<String>) {
	run(::topLevel)
}
fun topLevel() = println("I'm in a function!")

Lambda with Receivers

Semisal kita punya code seperti ini. Code ini akan mencetak angka dari 1 sampai 100. Bisa dilihat dia menggunakan variabel numbers secara berulang ulang.

fun countTo100(): String {
	val numbers = StringBuilder()
	for (i in 1..99) {
		numbers.append(i)
		numbers.append(", ")
	}
	numbers.append(100)
	return numbers.toString()
}

Kita bisa menggunakan command with untuk memangkas code tersebut, variable numbers akan di jadikan sebagai receivers. Fungsi append dan toString dia akan recive dari numbers. Code nya akan seperti berikut

fun countTo100() =
	val numbers = StringBuilder()
	with(numbers) {
	for (i in 1..99) {
		append(i)
		append(", ")
	}
	append(100)
	toString()
}

Lebih lanjut code nya bisa dipangkas seperti berikut

fun countTo100() =
	StringBuilder().apply() {
		for (i in 1..99) {
			append(i)
			append(", ")
		}
		append(100)
	}.toString()

Lambda Labelling

fun main(args: Array<String>) {
	"Some String".apply somestring@ {
		"Another String".apply {
			println(toLowerCase())
			println(this@somestring.toUpperCase())
		}
	}
}

Pada code di atas ada 2 string yang akan di print yaitu Some String dan Another String dimana masing masing berada dalam block lambda yang berbeda. Kita bisa akses value dari Some String dengan cara melabeli lambda tersebut (somestring). Sehinggal dapat dipanggil menggunakan `println(this@somestring.toUpperCase())``

Local Return

Di lambda ada yang namanya local return, dia akan return hanya block lambda yang sudah didefinisikan. Pada code berikut forEach di beri label returnBlock dan kemudian di panggil saat return. Karena hanya return block returnBlock saja maka code println(“Nope, there’s no employee with the last name $lastName”) tetap akan di eksekusi.

fun findByLastName(employees: List<Employee>, lastName: String) {
	employees.forEach returnBlock@ {
		if (it.lastName == lastName) {
			println("Yes, there's an employee with the last name $lastName")
			return@returnBlock
		}
	}
	println("Nope, there's no employee with the last name $lastName")
}

Jika function berikut di run

findByLastName(employees, "Wilson")
findByLastName(employees, "Smithson")

Hasilnya nanti seperti ini :

Yes, there's an employee with the last name Wilson
Nope, there's no employee with the last name Wilson
Nope, there's no employee with the last name Smithson

Jika function diganti menjadi berikut

fun findByLastName(employees: List<Employee>, lastName: String) {
	employees.forEach {
		if (it.lastName == lastName) {
			println("Yes, there's an employee with the last name $lastName")
			return
		}
	}
	println("Nope, there's no employee with the last name $lastName")
}

Hasilnya nanti seperti ini :

Yes, there's an employee with the last name Wilson
Nope, there's no employee with the last name Wilson

Lists

List bisa dideklarasikan seperti berikut

// contoh definisi list. dia sifatnya immutable
val strings = listOf("spring", "summer", "fall", "winter")

// contoh definisi empty list
val emptyList = emptyList<String>()

// contoh definisi not null list, tidak ada null value yang bisa masuk
val notNullList = listOfNotNull("hello", null, "goodbye")

// contoh definisi array list
val arraylist = arrayListOf(1, 2, 4)

// contoh definisi mutable list
val mutableList = mutableListOf<Int>(1, 2, 3)

// contoh casting array ke list
val array = arrayOf("black", "white", "green")
val colorList = array.toList()

// contoh definisi array of int
val ints = intArrayOf(1, 2, 3)

Spread Operator

Spread operator ini digunakan untuk mengubah suatu list atau aray dari tipe data X menjadi setiap variabel X dari list atau array tersebut. Berikut contoh nya

val array = arrayOf("black", "white", "green")
val colorList = listOf(*array)

Collection Function

Berikut contoh beberapa collection function di kotlin

val strings = listOf("spring", "summer", "fall", "summer", "winter")
val colorList = listOf("black", "white", "red", "black", "red")
val ints = listOf(1, 2, 3, 4, 5)

// mengambil data terakhir dari list
println(strings.last())

// merevese data di dalam list
println(strings.asReversed())

// mengambil data secara null safe dengan memasukkan index
println(strings.getOrNull(5))

// mengambil maksimal value
println(ints.max())

// menggabungkan data 2 list
val combinedList = colorList + strings
println(combinedList)

// menggabungkan data 2 list + distinct
val noDupsList = colorList.union(strings)
println(noDupsList)

// mendistinct list tertentu
val noDupColors = colorList.distinct()
println(noDupColors

// map function
val ints = arrayOf(1, 2, 3, 4, 5)
val add10List = ints.map { it + 10 }
println(add10List.javaClass)
val immutableMap = mapOf<Int, Car>(1 to Car("green", "Toyota", 2015),
2 to Car("red", "Ford", 2016),
3 to Car("silver", "Honda", 2013),
17 to Car("red", "BMW", 2015),
8 to Car("green", "Ford", 2010))
println(immutableMap.toSortedMap())

// hitung jumlah
println(immutableMap.count { it.value.year > 2014 })

// check if all exist
println(immutableMap.all { it.value.year > 2014 })

// check if atleast one exist
println(immutableMap.any { it.value.year > 2014 })

// find first
println(cars.find { it.year > 2014 })

// group by
println(cars.groupBy { it.color })

// sorted by
println(cars.sortedBy { it.year })

Map

Beriku adalah contoh deklarasi map di kotlin

// deklarasi map, dia bersifat immutable
val immutableMap = mapOf<Int, Car>(1 to Car("green", "Toyota", 2015),
2 to Car("red", "Ford", 2016),
3 to Car("silver", "Honda", 2013))

// deklarasi hashmap, dia bersifat mutable
val mutableMap = hashMapOf<String, Car>("John's car" to Car("red",
"Range Rover", 2010),
"Jane's car" to Car("blue", "Hyundai", 2012))

// destrukturing map
for ((k, v) in mutableMap) {
 println(k)
 println(v)
}

// destrukturing pair
val pair = Pair(10, "ten")
val (firstValue, secondValue) = pair
println(firstValue)
println(secondValue)

// destrukturing data class
data class Car(val color: String, val model: String, val year: Int)
val car = Car("blue", "Corvette", 1959)
val (color, model, year) = car
println("color = $color, model = $model, and year = $year")

Sets

Beriku adalah contoh deklarasi sets di kotlin

// deklarasi set
val setInts = setOf(10, 15, 19, 5, 3, -22)
println(setInts.plus(20)) // menambah variabel bervalue 20
println(setInts.plus(10)) // menambah variabel bervalue 10
println(setInts.minus(19)) // menghapus variabel bervalue 19
println(setInts.minus(100)) // menghapus variabel bervalue 100
println(setInts.average()) // menghitung rata rata
println(setInts.drop(3)) // menghapus 3 variabel pertama

// deklarasi mutable set
val mutableInts = mutableSetOf(1, 2, 3, 4, 5)

🔔 Jika anda menyukai artikel ini, silahkan subscribe agar anda bisa mendapatkan notifikasi jika ada artikel baru atau anda bisa melihat artikel yang telah dipublikasikan disini. 🚀
📝 Jika ada pertanyaan atau saran, anda bisa menulisnya di kolom komentar atau mengirim pesan lewat Medium.
Thank you for your support! 🌟