Collections & Kotlin Advanced

val names: List<String> = listOf("Pyron", "Aquara")
val elements: Set<String> = setOf("FIRE", "WATER", "FIRE")
val byId: Map<Int, String> = mapOf(1 to "Pyron")
println("${names.size} monsters, ${elements.size} elements, ${byId[1]}")

2 monsters, 2 elements, Pyron

val roster: List<String> = listOf("Pyron", "Aquara")
val editable: MutableList<String> = mutableListOf("Pyron")
editable.add("Aquara")
println("${roster.size} / ${editable.size}")

2 / 2

val monsters = mutableListOf("Pyron")
monsters.add("Aquara")
println(monsters)
// monsters = mutableListOf("Zephyra") // Compile error.

[Pyron, Aquara]

val names: Iterable<String> = listOf("Pyron", "Aquara")
for (name in names) println(name)

Pyron
Aquara

val it = listOf("Pyron", "Aquara").iterator()
while (it.hasNext()) println(it.next())

Pyron
Aquara

val monsters = mutableListOf("Pyron", "Aquara")
val it = monsters.iterator()
while (it.hasNext()) if (it.next() == "Aquara") it.remove()
println(monsters)

[Pyron]

val names = listOf("Pyron", "Aquara", "Pyron")
println(names[0])
println(names.getOrNull(9))

Pyron
null

val monsters = mutableListOf("Pyron")
monsters.add("Aquara")
monsters[0] = "Pyron Prime"
println(monsters)

[Pyron Prime, Aquara]

val elements = setOf("FIRE", "WATER", "FIRE")
println(elements.size)
println("FIRE" in elements)

2
true

val elements = mutableSetOf("FIRE")
println(elements.add("WATER"))
println(elements.add("FIRE"))
println(elements.size)

true
false
2

val monsters = mapOf(1 to "Pyron", 2 to "Aquara")
println(monsters[2])
println(monsters[99])

Aquara
null

val monsters = mutableMapOf(1 to "Pyron")
monsters[2] = "Aquara"
monsters.remove(1)
println(monsters[2])

Aquara

val roster = buildList {
    add("Pyron")
    add("Aquara")
}
println(roster)

[Pyron, Aquara]

val monsters = listOf("Pyron", "Aquara")
println(monsters.size)
println(monsters.isNotEmpty())

2
true

val names = listOf("Pyron", "Aquara", "Zephyra")
println(names.indices.toList())
println(names.subList(0, 2))

[0, 1, 2]
[Pyron, Aquara]

data class MonsterKey(val id: Int, val element: String)
val keys = setOf(MonsterKey(1, "FIRE"), MonsterKey(1, "FIRE"))
println(keys.size)

1

val names = listOf("Pyron", "Aquara")
println(names.map { it.uppercase() })

[PYRON, AQUARA]

data class Monster(val name: String, val element: String)
val monsters = listOf(Monster("Pyron", "FIRE"), Monster("Aquara", "WATER"))
println(monsters.filter { it.element == "FIRE" }.map { it.name })

[Pyron]

val names = listOf("Pyron", "Aquara")
println(names.find { it.startsWith("A") })
println(names.find { it.startsWith("Z") })

Aquara
null

val hp = listOf(100, 110, 0)
println(hp.any { it == 0 })
println(hp.all { it >= 0 })

true
true

data class Monster(val name: String, val speed: Int)
val monsters = listOf(Monster("Pyron", 110), Monster("Aquara", 95))
println(monsters.sortedByDescending { it.speed }.map { it.name })

[Pyron, Aquara]

data class Ranking(val points: Int) : Comparable<Ranking> {
    override fun compareTo(other: Ranking): Int = points.compareTo(other.points)
}
println(listOf(Ranking(5), Ranking(2)).sorted())

[Ranking(points=2), Ranking(points=5)]

data class Monster(val name: String, val speed: Int)
val monsters = listOf(Monster("Pyron", 110), Monster("Zephyra", 110))
val order = compareByDescending<Monster> { it.speed }.thenBy { it.name }
println(monsters.sortedWith(order).map { it.name })

[Pyron, Zephyra]

data class Monster(val id: Int, val name: String)
val monsters = listOf(Monster(1, "Pyron"), Monster(2, "Aquara"))
println(monsters.associateBy { it.id }[2]?.name)

Aquara

data class Monster(val id: Int, val name: String)
val monsters = listOf(Monster(1, "Pyron"), Monster(2, "Aquara"))
println(monsters.associate { it.id to it.name })

{1=Pyron, 2=Aquara}

data class Monster(val name: String, val element: String)
val monsters = listOf(Monster("Pyron", "FIRE"), Monster("Ember", "FIRE"))
println(monsters.groupBy { it.element }.mapValues { it.value.size })

{FIRE=2}

val hp = listOf(100, 0, 35)
val (alive, defeated) = hp.partition { it > 0 }
println("$alive | $defeated")

[100, 35] | [0]

val names = listOf("Pyron", "Aquara", "Zephyra", "Ember", "Ripple")
println(names.chunked(2))

[[Pyron, Aquara], [Zephyra, Ember], [Ripple]]

val damage = listOf(18, 20, 15, 25)
println(damage.windowed(size = 2))

[[18, 20], [20, 15], [15, 25]]

val result = sequenceOf(1, 2, 3, 4)
    .filter { it % 2 == 0 }
    .map { it * 10 }
    .toList()
println(result)

[20, 40]

val values = listOf(1, 2, 3)
val eager = values.map { it * 2 }
val lazy = values.asSequence().map { it * 2 }
println(eager)
println(lazy.toList())

[2, 4, 6]
[2, 4, 6]

data class Monster(val name: String, val hp: Int)
fun Monster.isAlive(): Boolean = hp > 0
println(Monster("Pyron", 100).isAlive())

true

open class Monster
class FireMonster : Monster()
fun Monster.describe() = "Monster"
fun FireMonster.describe() = "FireMonster"
val monster: Monster = FireMonster()
println(monster.describe())

Monster

data class Monster(var name: String, var hp: Int)
val monster = Monster("Pyron", 100).apply { hp = 95 }
monster.also { println(it.name) }
println(monster.run { hp })
println(with(monster) { name.length })
println(monster.let { it.hp > 0 })

Pyron
95
5
true

fun <T> firstOrNull(items: List<T>): T? = items.firstOrNull()
println(firstOrNull(listOf("Pyron", "Aquara")))
println(firstOrNull(emptyList<Int>()))

Pyron
null

data class Monster(val name: String, val hp: Int) {
    companion object {
        fun starter(name: String) = Monster(name, 100)
    }
}
println(Monster.starter("Pyron"))

Monster(name=Pyron, hp=100)

object DamageRules {
    fun calculate(attack: Int, defense: Int): Int = maxOf(1, attack - defense)
}
println(DamageRules.calculate(30, 12))

18

fun calculateDamage(attack: Int, defense: Int): Int = maxOf(1, attack - defense)
class Monster(var hp: Int) {
    fun takeDamage(damage: Int) { hp = maxOf(0, hp - damage) }
}
val monster = Monster(100)
monster.takeDamage(calculateDamage(30, 12))
println(monster.hp)

82

val elementLabel: String by lazy { "FIRE / WATER / WIND" }
println(elementLabel)

FIRE / WATER / WIND

// Fragment in MonsterRoutes.kt, inside GET /monsters.
val rawElement = call.request.queryParameters["element"]
val rawSort = call.request.queryParameters["sort"]

val element = rawElement?.let { raw ->
    enumValues<Element>().firstOrNull { it.name == raw }
        ?: throw BadRequestException("Invalid element")
}
if (rawSort != null && rawSort !in setOf("name", "speed")) {
    throw BadRequestException("Invalid sort")
}
call.respond(service.list(element, rawSort))

GET /monsters?element=FIRE&sort=speed -> 200 OK (Pyron)
GET /monsters?element=UNKNOWN -> 400 Bad Request

// Unit test (fragment): repository contains Pyron and Aquara.
@Test
fun fireFilterReturnsOnlyFireMonsters() {
    val service = MonsterService(InMemoryMonsterRepository())
    val names = service.list(Element.FIRE).map { it.name }
    assertEquals(listOf("Pyron"), names)
}

Verwacht: test slaagt; lijst bevat alleen Pyron.