Kolekcje w Kotlinie to jedne z najpotężniejszych narzędzi języka do efektywnego przechowywania, przetwarzania i transformacji danych. Kotlin wprowadza wyraźne rozróżnienie między kolekcjami immutable (niezmiennymi) i mutable (zmiennymi), zapewniając zarówno bezpieczeństwo, jak i elastyczność. Standardowa biblioteka w pakiecie kotlin.collections oferuje List, Set i Map, które mają krótszy i bardziej funkcjonalny interfejs API niż kolekcje Javy – szczególnie w połączeniu z lambdami i funkcjami rozszerzającymi stają się bardzo potężne. W 2026 roku te struktury są intensywnie używane w Androidzie (adaptery RecyclerView, zapytania bazy danych Room), backendzie (odpowiedzi Ktor/Spring Boot) oraz projektach Kotlin Multiplatform (wspólna logika biznesowa).W Google wyszukiwania takie jak "Kotlin list", "Kotlin map", "Kotlin mutableListOf", "Kotlin collections" mają jeden z najwyższych wolumenów wśród tematów Kotlina w Polsce i na świecie. Dobre zrozumienie kolekcji poprawia wydajność kodu (na przykład Set z kontrolą członkostwa O(1)), zmniejsza błędy (preferując immutable dla thread-safety) i ułatwia transformacje w stylu programowania funkcjonalnego.Dlaczego Warto Uczyć Się Kolekcji? (Perspektywa 2026)- Bezpieczeństwo: Kolekcje immutable są domyślne – chronią integralność danych, zwłaszcza w projektach multi-thread lub multiplatform.
- Zwięzłość:listOf(), mapOf(), setOf() do tworzenia w jednej linii; map/filter/reduce do łańcuchowych operacji.
- Wydajność: Kolekcje Kotlina są kompatybilne z Javą, ale inteligentniejsze (leniwe sekwencje, optymalizacje tablic).
- Zastosowania w świecie rzeczywistym: Odpowiedzi API (JSON → List<DataClass>), wyniki bazy danych (Room → Flow<List<Entity>>), stan UI (Compose → mutableStateListOf).
- Zaleta multiplatform: Ten sam kod kolekcji działa na Androidzie, iOS i backendzie.
1. List (Lista) - Kolekcja UporządkowanaListy to najczęściej używane struktury. Są uporządkowane, pozwalają na duplikaty elementów, dostęp po indeksie.// Immutable List (zalecana - bezpieczna)
val owoce = listOf("jabłko", "gruszka", "wiśnia", "jabłko") // duplikaty dozwolone
println(owoce[1]) // gruszka
println(owoce.size) // 4
println(owoce.indexOf("wiśnia")) // 2
println(owoce.contains("banan")) // false
// Mutable List
val mutableOwoce = mutableListOf("banan", "winogrono")
mutableOwoce.add("pomarańcza") // dodaj na końcu
mutableOwoce.add(1, "kiwi") // dodaj na indeksie
mutableOwoce.remove("banan") // usuń wartość
mutableOwoce[0] = "ananas" // zmień
println(mutableOwoce) // [ananas, kiwi, winogrono, pomarańcza]
// Slicing i subList
println(owoce.subList(1, 3)) // [gruszka, wiśnia]
// Powszechne transformacje (styl funkcjonalny)
val duzeLitery = owoce.map { it.uppercase() } // wszystkie wielkimi literami
val dlugieZnaki = owoce.filter { it.length > 5 } // filtruj
val posortowane = owoce.sorted() // alfabetycznie
val sumaDlugosci = owoce.fold(0) { acc, owoc -> acc + owoc.length } // suma długości
println(duzeLitery) // [JABŁKO, GRUSZKA, WIŚNIA, JABŁKO]Optymalizacja ArrayList: mutableListOf() używa w tle ArrayList – szybkie dla dużych danych.2. Set (Zbiór) - Kolekcja Bez DuplikatówSety są nieuporządkowane, nie pozwalają na duplikaty elementów, kontrola członkostwa jest bardzo szybka (oparta na HashSet).// Immutable Set
val unikalne = setOf(1, 2, 2, 3, 4) // 2 duplikat, zostaje jeden
println(unikalne) // [1, 2, 3, 4]
// Mutable Set
val mutableSet = mutableSetOf("czerwony", "zielony")
mutableSet.add("niebieski")
mutableSet.add("zielony") // nie doda
mutableSet.remove("czerwony")
// Operacje na zbiorach
val set1 = setOf(1, 2, 3)
val set2 = setOf(3, 4, 5)
println(set1 union set2) // [1, 2, 3, 4, 5]
println(set1 intersect set2) // [3]
println(set1 - set2) // [1, 2] (różnica)
// Członkostwo (bardzo szybkie)
println(3 in set1) // trueDla LinkedHashSet i SortedSet: linkedSetOf(), sortedSetOf().3. Map (Słownik) - Pary Klucz-WartośćMapy przechowują pary klucz-wartość, klucze są unikalne.// Immutable Map
val osoba = mapOf("imie" to "Mehmet", "wiek" to 35, "miasto" to "Ankara")
println(osoba["imie"]) // Mehmet
println(osoba.keys) // [imie, wiek, miasto]
println(osoba.values) // [Mehmet, 35, Ankara]
println(osoba.entries) // pary klucz-wartość
// Mutable Map
val mutableMap = mutableMapOf("pensja" to 5000)
mutableMap["departament"] = "IT" // dodaj/aktualizuj
mutableMap += "bonus" to 1000 // operator +
mutableMap -= "pensja" // usuń
// Bezpieczny dostęp
println(osoba.getOrDefault("email", "Brak")) // Brak
// Transformacje
val imionaDuze = osoba.mapKeys { it.key.uppercase() }
val wiekZwiekszony = osoba.mapValues { if (it.key == "wiek") it.value + 1 else it.value }
// Zagnieżdżona Map
val firma = mutableMapOf(
"pracownik1" to mapOf("imie" to "Ayşe", "pensja" to 6000),
"pracownik2" to mapOf("imie" to "Ali", "pensja" to 7000)
)
println(firma["pracownik1"]?.get("pensja")) // 6000Dla LinkedHashMap i SortedMap: linkedMapOf(), sortedMapOf().Porównanie cech:- Uporządkowana: List - Tak; Set - Nie (LinkedHashSet tak); Map - Nie (LinkedHashMap tak).
- Duplikaty elementów: List - Tak; Set - Nie; Map - Klucze nie.
- Zmienna: List - mutableListOf; Set - mutableSetOf; Map - mutableMapOf.
- Domyślna (Immutable): List - listOf; Set - setOf; Map - mapOf.
- Dostęp: List - Indeks; Set - Członkostwo (in); Map - Klucz.
- Wydajność (Wyszukiwanie): List - O(n); Set - O(1) średnio; Map - O(1) średnio.
Zaawansowane Zastosowania i Wskazówki• Sequence (Leniwa Ewaluacja): Przyjazna dla pamięci w dużych danych.val lazySeq = generateSequence(1) { it + 1 }.take(1000000).filter { it % 2 == 0 }
println(lazySeq.sum()) // Oblicza tylko gdy potrzebne• Destructuring: Dla entries Map.for ((klucz, wartosc) in osoba) {
println("$klucz: $wartosc")
}• Specjalne dla Android/Compose: mutableStateListOf(), snapshotFlow dla reaktywnego UI.• Multiplatform: Expect/actual dla specyficznych dla platformy kolekcji (np. Array w JS).Wniosek i Praktyczne SugestieKolekcje ujawniają funkcjonalną moc Kotlina – preferuj immutable, mutable tylko gdy konieczne. Zły wybór traci wydajność, dobry czyni profesjonalnym.Praktyka:- Aplikacja koszyka zakupowego: mutableListOf<Produkt>, Map<String, Int> (produkt → ilość).
- Licznik unikalnych słów: Set<String> do analizy tekstu.
- Przykład parsowania JSON: Gson/Moshi do List<DataClass>.
- Źródła: Dokumentacja Kotlin (collections), książka "Atomic Kotlin".
Ten przewodnik pozwoli ci w pełni opanować kolekcje. W rzeczywistych projektach (przetwarzanie odpowiedzi API, zapytania bazy danych) te struktury dadzą ci dużą przewagę. Dla przykładowego projektu lub konkretnej kolekcji zostaw komentarz! Powodzenia w aplikacjach Kotlina w 2026.
Łatwo było mi to zrozumieć. Podziękowanie.