List of lectures for the course Kotlin, 19 quest level on JavaRush

Creating collections
Kotlin SELF
19 level,0 lecture
We break down why fixed-size arrays quickly become inconvenient in “real” programs, and how Kotlin collections solve this problem. We compare the basic containers List/ Set/ Map, understand the difference between read-only and mutable interfaces ( List vs MutableList), reinforce an important rule about val and an object’s mutability, learn how to create collections via listOf, mutableListOf, setOf, mapOf, and also how to correctly initialize empty collections with a type hint. At the end: a mini sketch of a console app and common beginner mistakes.
Open
List and MutableList — order, indices, basic operations
Kotlin SELF
19 level,1 lecture
We’ll break down how read-only List<T> differs from mutable MutableList<T>, how indices work (from 0 to lastIndex), why you must not mix up size and lastIndex, and which operations you typically need in practice: reading via [ i ] / get, replacing via set, adding with add, deleting with removeAt/ remove, and checking with contains / the in operator.
Open
Set and MutableSet — uniqueness and membership checks
Kotlin SELF
19 level,2 lecture
We break down why sets are needed in Kotlin: how Set differs from List, why Set stores only unique elements, how add()/ remove() work with a Boolean result, membership checks via contains() and the in operator, and a quick way to “remove duplicates” with toSet(). At the end — a practical mini example with expense tracking and a walkthrough of common mistakes.
Open
Map and MutableMap: reading V?, updating by key, the “counter” pattern
Kotlin SELF
19 level,3 lecture
We break down how Map<K, V> and MutableMap<K, V> work in Kotlin: why reading map[key] returns V?, how to correctly handle a missing key using ?: and the key in map check, how to write/update values via map[key] = value, delete via remove, and how to apply the practical “counter” pattern for counting and summing by categories.
Open
Generics on collections + minimal data structure for a practical project
Kotlin SELF
19 level,4 lecture
We break down generics in Kotlin collections: how to “read” types like List<String> and Map<K, V>, why empty collections need an explicit type, why accessing map[key] always returns a nullable ( V?), how not to kill readability with nested types, and how to assemble a minimal data structure for a console mini expense tracker using Triple, Pair, MutableList, and MutableMap. At the end: common mistakes and practical habits (read-only API, key normalization).
Open