Comment travailler avec des collections en Kotlin…

En Kotlin, les collections représentent des groupes d’objets. Elles peuvent être modifiables (mutable) ou immutables (immutable).

Collections immutables (Immutable):

Leur contenu ne peut pas être modifié après leur création.
Sont sûres pour la lecture dans des environnements concurrents.
Types de base : List, Set, Map.

val numbers: List<Int> = listOf(1, 2, 3) // Création d’une liste immuable
// numbers.add(4) // Erreur de compilation : collection immuable

Collections modifiables (Mutable):

Leur contenu peut être modifié (ajout, suppression, modification d’éléments).
Ne sont pas sûres pour l’accès concurrent par défaut (synchronisation manuelle requise).
Types de base : MutableList, MutableSet, MutableMap.

val mutableNumbers: MutableList<Int> = mutableListOf(1, 2, 3) // Création d’une liste modifiable
mutableNumbers.add(4) // Ajout d’un élément
mutableNumbers.remove(2) // Suppression d’un élément

Types principaux de collections :

List : Collection ordonnée permettant les doublons. Accès par index.

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

Set : Collection non ordonnée ne permettant pas les doublons. Les éléments sont uniques.

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

Map : Collection de paires clé-valeur. Chaque clé est unique.

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

Fonctions d’extension pour travailler avec les collections (fonctions d’ordre supérieur) :

Kotlin offre de nombreuses fonctions d’extension puissantes pour manipuler les collections :

filter : Crée une nouvelle collection contenant uniquement les éléments qui satisfont un prédicat.
```
val evenNumbers = numbers.filter { it % 2 == 0 } // [2]
```
map : Transforme chaque élément en un nouvel élément, créant une nouvelle collection.
```
val squaredNumbers = numbers.map { it * it } // [1, 4, 9]
```

forEach : Exécute une action pour chaque élément.

numbers.forEach { println(it) } // Affiche 1, 2, 3 ligne par ligne

reduce : Combine tous les éléments en une seule valeur en utilisant une opération.
```
val sum = numbers.reduce { acc, i -> acc + i } // 6
```

fold : Semblable à reduce, mais prend une valeur initiale.

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

sortedBy : Trie la collection selon une valeur extraite de chaque élément.

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

groupBy : Regroupe les éléments par une clé extraite de chaque élément.

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

Conversion entre types de collections :

Il est facile de convertir un type de collection en un autre, ainsi qu’entre versions modifiables et immutables :

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

Travailler avec les collections en Kotlin est grandement simplifié grâce à la richesse de la bibliothèque standard et aux fonctions d’extension.

Comment travailler avec des collections en Kotlin?