Cum să lucrezi cu colecții în Kotlin?

În Kotlin, colecțiile reprezintă grupuri de obiecte. Ele pot fi modificabile (mutable) sau nemodificabile (immutable).

Colecții nemodificabile (Immutable):

Conținutul nu poate fi schimbat după crearea lor.
Sunt sigure pentru citire în medii concurente.
Tipuri de bază: List, Set, Map.

val numbers: List<Int> = listOf(1, 2, 3) // Crearea unei liste nemodificabile
// numbers.add(4) // Eroare de compilare: colecție nemodificabilă

Colecții modificabile (Mutable):

Conținutul poate fi schimbat (adăugare, ștergere, modificare de elemente).
Nu sunt sigure pentru acces concurent implicit (se necesită sincronizare manuală).
Tipuri de bază: MutableList, MutableSet, MutableMap.

val mutableNumbers: MutableList<Int> = mutableListOf(1, 2, 3) // Crearea unei liste modificabile
mutableNumbers.add(4) // Adăugare element
mutableNumbers.remove(2) // Ștergere element

Tipuri principale de colecții:

List: Colecție ordonată, permite duplicate. Acces pe bază de index.

val names: List<String> = listOf("Alice", "Bob", "Alice")
println(names[0]) // "Alice"

Set: Colecție neordonată, nu permite duplicate. Elementele sunt unice.

val uniqueNumbers: Set<Int> = setOf(1, 2, 2, 3)
println(uniqueNumbers) // [1, 2, 3]

Map: Colecție de perechi cheie-valoare. Fiecare cheie este unică.

val ages: Map<String, Int> = mapOf("Alice" to 30, "Bob" to 25)
println(ages["Alice"]) // 30

Funcții de extensie pentru lucrul cu colecțiile (funcții de ordin superior):

Kotlin oferă multe funcții de extensie puternice pentru manipularea colecțiilor:

filter: Creează o colecție nouă conținând doar elementele care satisfac un predicat.
```
val evenNumbers = numbers.filter { it % 2 == 0 } // [2]
```
map: Transformă fiecare element într-un nou element, creând o colecție nouă.
```
val squaredNumbers = numbers.map { it * it } // [1, 4, 9]
```

forEach: Execută o acțiune pentru fiecare element.

numbers.forEach { println(it) } // Va afișa 1, 2, 3 pe rând

reduce: Combină toate elementele într-o singură valoare folosind o operație.
```
val sum = numbers.reduce { acc, i -> acc + i } // 6
```

fold: Similar cu reduce, dar acceptă o valoare inițială.

val sumWithInitial = numbers.fold(10) { acc, i -> acc + i } // 16 (10 + 1 + 2 + 3)

sortedBy: Sortează colecția după o valoare extrasă din fiecare element.

val sortedNames = listOf("Charlie", "Alice", "Bob").sortedBy { it } // [Alice, Bob, Charlie]

groupBy: Grupează elementele după o cheie extrasă din fiecare element.

val groupedNumbers = numbers.groupBy { if (it % 2 == 0) "even" else "odd" } // {odd=[1, 3], even=[2]}

Conversia între tipuri de colecții:

Este ușor să convertești un tip de colecție în altul, precum și între versiunile modificabile și nemodificabile:

val mutableList: MutableList<Int> = listOf(1, 2, 3).toMutableList()
val immutableList: List<Int> = mutableListOf(4, 5, 6).toList()

Lucrul cu colecțiile în Kotlin este mult simplificat datorită bogăției bibliotecii standard și funcțiilor de extensie.