Utiliser les collections en Kotlin

1. Introduction

Vous avez probablement observé que, dans de nombreuses applications, les données s'affichent sous forme de liste : contacts, paramètres, résultats de recherche, etc.

Cependant, dans le code que vous avez écrit jusqu'à présent, vous avez principalement travaillé avec des données constituées d'une seule valeur, comme un nombre ou un extrait de texte affiché à l'écran. Pour créer des applications impliquant des quantités arbitraires de données, vous devez apprendre à vous servir des collections.

Les types de collections (parfois appelés "structures de données") vous permettent de stocker plusieurs valeurs, généralement de même type, de manière organisée. Une collection peut être une liste numérotée, un groupe de valeurs uniques ou le mappage de valeurs d'un certain type vers un autre type de données. Utiliser les collections à bon escient vous permet d'implémenter des fonctionnalités courantes des applications Android, telles que les listes déroulantes, et de résoudre divers problèmes de programmation impliquant des quantités arbitraires de données.

Cet atelier de programmation explique comment utiliser plusieurs valeurs dans le code et présente diverses structures de données, y compris des tableaux, des listes, des ensembles et des mappages.

Conditions préalables

• Vous maîtrisez la programmation orientée objet en Kotlin, y compris les classes, les interfaces et les éléments génériques.

Points abordés

• Créer et modifier des tableaux
• Utiliser List et MutableList
• Utiliser Set et MutableSet
• Utiliser Map et MutableMap

Ce dont vous avez besoin

• Un navigateur Web ayant accès à Kotlin Playground

2. Tableaux en Kotlin

Qu'est-ce qu'un tableau ?

Un tableau est le moyen le plus simple de regrouper un nombre arbitraire de valeurs dans vos programmes.

De même qu'un groupe de modules solaires s'appelle un panneau solaire, ou que l'apprentissage de Kotlin ouvre un éventail de possibilités pour votre carrière de programmeur, un Array représente plusieurs valeurs. Plus précisément, un tableau est une séquence de valeurs qui ont le même type de données.

• Un tableau contient plusieurs valeurs appelées éléments.
• Les éléments d'un tableau sont ordonnés et sont accessibles via un indice.

Qu'est-ce qu'un indice ? Un indice est un nombre entier correspondant à un élément du tableau. Il indique la distance d'un élément par rapport à l'élément de départ dans le tableau. C'est ce qu'on appelle l'indexation zéro. L'indice du premier élément du tableau est 0, tandis que l'indice du deuxième élément est 1, car il se trouve à une distance de 1 unité du premier, et ainsi de suite.

Dans la mémoire de l'appareil, les éléments du tableau sont stockés l'un à côté de l'autre. Bien que les détails de ce concept n'entrent pas dans le cadre de cet atelier de programmation, il a deux implications importantes :

• L'accès à un élément du tableau par son indice est rapide. Vous pouvez accéder à n'importe quel élément aléatoire d'un tableau via son indice dans un temps sensiblement identique à celui nécessaire pour accéder à tout autre élément aléatoire. C'est pourquoi on dit que les tableaux ont un accès aléatoire.
• Un tableau a une taille fixe. En d'autres termes, vous ne pouvez pas ajouter d'éléments à un tableau au-delà de cette taille. Si vous tentez d'accéder à l'élément dont l'indice correspond à 100 dans un tableau de 100 éléments, vous obtiendrez une exception. En effet, l'indice le plus élevé est 99, car l'indice du premier élément est toujours 0, et non 1. Vous pouvez toutefois modifier les valeurs au niveau des indices du tableau.

Remarque : Dans cet atelier de programmation, la mémoire fait référence à la mémoire vive (RAM) aléatoire de l'appareil, et non à un stockage persistant à long terme. C'est ce que l'on appelle un "accès aléatoire", car il est possible d'accéder rapidement à n'importe quel emplacement arbitraire dans la mémoire.

Pour déclarer un tableau dans le code, utilisez la fonction arrayOf().

La fonction arrayOf() utilise les éléments du tableau comme paramètres et renvoie un tableau dont le type correspond aux paramètres transmis. Elle peut sembler légèrement différente des autres fonctions que vous avez vues, car arrayOf() comporte un nombre variable de paramètres. Si vous transmettez deux arguments à arrayOf(), le tableau obtenu contiendra deux éléments, avec les indices 0 et 1. Si vous transmettez trois arguments, le tableau obtenu comportera trois éléments, avec des indices compris entre 0 et 2.

Observons les tableaux en action grâce à une petite exploration du système solaire.

1. Accédez à Kotlin Playground.
2. Dans main(), créez une variable rockPlanets. Appelez arrayOf(), en transmettant le type String, ainsi que quatre chaînes, une pour chacune des planètes rocheuses du système solaire.

val rockPlanets = arrayOf<String>("Mercury", "Venus", "Earth", "Mars")

3. Comme Kotlin utilise l'inférence de type, vous pouvez omettre le nom du type lorsque vous appelez arrayOf(). Sous la variable rockPlanets, ajoutez une autre variable gasPlanets, sans transmettre de type entre crochets.

val gasPlanets = arrayOf("Jupiter", "Saturn", "Uranus", "Neptune")

4. Les tableaux vous permettent d'effectuer des tâches intéressantes. Par exemple, comme avec les types numériques Int ou Double, vous pouvez ajouter deux tableaux. Créez une variable appelée solarSystem et définissez-la sur le résultat rockPlanets et gasPlanets à l'aide de l'opérateur plus (+). Cette action génère un nouveau tableau contenant tous les éléments du tableau rockPlanets et ceux du tableau gasPlanets.

val solarSystem = rockPlanets + gasPlanets

5. Exécutez votre programme pour vérifier qu'il fonctionne. Aucun résultat ne doit s'afficher pour le moment.

Accéder à un élément d'un tableau

Vous pouvez accéder à un élément d'un tableau via son indice.

C'est ce qu'on appelle la syntaxe d'indice. Elle se compose de trois parties :

• Le nom du tableau
• Un crochet d'ouverture ([) et un crochet de fermeture (])
• L'indice de l'élément du tableau entre crochets

Accédons aux éléments du tableau solarSystem selon leur indice.

1. Dans main(), affichez et imprimez chaque élément du tableau solarSystem. Notez que le premier indice est 0 et que le dernier est 7.

println(solarSystem[0])
println(solarSystem[1])
println(solarSystem[2])
println(solarSystem[3])
println(solarSystem[4])
println(solarSystem[5])
println(solarSystem[6])
println(solarSystem[7])

2. Exécutez votre programme. Les éléments s'affichent dans le même ordre que lorsque vous avez appelé arrayOf().

Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Vous pouvez également définir la valeur d'un élément de tableau en fonction de son indice.

La procédure d'accès à l'indice est la même que précédemment mentionné : le nom du tableau, suivi de crochets contenant l'indice. Viennent ensuite l'opérateur d'attribution (=) et une nouvelle valeur.

Voyons comment modifier les valeurs du tableau solarSystem.

1. Donnez un nouveau nom à Mars pour ses futurs colons. Accédez à l'élément ayant l'indice 3 et définissez-le sur "Little Earth".

solarSystem[3] = "Little Earth"

2. Imprimez l'élément au niveau de l'indice 3.

println(solarSystem[3])

3. Exécutez votre programme. Le quatrième élément du tableau (au niveau de l'indice 3) est mis à jour.

...
Little Earth

4. Imaginons maintenant que les scientifiques aient découvert qu'il y avait une neuvième planète après Neptune, appelée Pluton. Comme indiqué précédemment, vous ne pouvez pas redimensionner un tableau. Que se passerait-il si vous essayiez ? Essayons d'ajouter Pluton au tableau solarSystem. Ajoutez Pluton au niveau de l'indice 8, car il s'agit du 9e élément du tableau.

solarSystem[8] = "Pluto"

5. Exécutez votre code. Une exception ArrayIndexOutOfBounds est générée. Comme le tableau contenait déjà huit éléments, comme prévu, vous ne pouvez pas y ajouter un neuvième élément.

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 8 out of bounds for length 8

6. Supprimez l'ajout de Pluton dans le tableau.

Code à supprimer

solarSystem[8] = "Pluto"

7. Si vous souhaitez agrandir la taille d'un tableau, vous devez en créer un autre. Définissez une nouvelle variable appelée newSolarSystem, comme illustré ci-dessous. Ce tableau peut stocker neuf éléments au lieu de huit.

val newSolarSystem = arrayOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto")

8. Essayez maintenant d'imprimer l'élément dont l'indice correspond à 8.

println(newSolarSystem[8])

9. Exécutez votre code et remarquez qu'il s'exécute sans exception.

...
Pluto

Bravo ! Grâce à vos connaissances sur les tableaux, vous pouvez maintenant faire presque tout ce que vous voulez avec les collections.

Mais pas si vite ! Bien que les tableaux soient l'un des aspects fondamentaux de la programmation, l'utilisation d'un tableau pour des tâches nécessitant l'ajout et la suppression d'éléments, l'unicité dans une collection ou la mise en correspondance d'objets avec d'autres n'est pas particulièrement simple, et le code de votre application peut rapidement devenir un puits sans fond.

C'est pourquoi la plupart des langages de programmation, y compris Kotlin, implémentent des types de collections spéciaux pour gérer les situations qui se produisent généralement dans des applications réelles. Dans les sections suivantes, vous découvrirez trois collections courantes : List, Set et Map. Vous vous familiariserez également avec les propriétés et méthodes courantes, ainsi qu'avec les situations dans lesquelles ces types de collections doivent être utilisés.

3. Listes

Une liste est une collection triée et redimensionnable, généralement implémentée en tant que tableau redimensionnable. Lorsque le tableau est plein et que vous essayez d'insérer un nouvel élément, il est copié dans un nouveau tableau de plus grande taille.

Avec une liste, vous pouvez également insérer de nouveaux éléments entre d'autres éléments au niveau d'un indice spécifique.

C'est pour cette raison que les listes peuvent accepter des éléments en plus ou en moins. Dans la plupart des cas, l'ajout d'un élément à une liste prend le même temps, quel que soit le nombre d'éléments qu'elle contient. De temps en temps, si l'ajout d'un nouvel élément dépasse la taille définie du tableau, il se peut que les éléments existants doivent être déplacés pour laisser de la place aux nouveaux. Les listes s'occupent de cela pour vous. Toutefois, en arrière-plan, le principe est le même : un tableau est remplacé par un nouveau tableau lorsque cela est nécessaire.

List et MutableList

Les types de collections que vous rencontrerez en Kotlin implémentent une ou plusieurs interfaces. Comme vous l'avez appris dans l'atelier de programmation Génériques, objets et extensions plus tôt dans ce module, les interfaces fournissent un ensemble standard de propriétés et de méthodes permettant d'implémenter une classe. Une classe qui implémente l'interface List fournit des implémentations pour toutes les propriétés et méthodes de l'interface List. Il en va de même pour MutableList.

Que font List et MutableList ?

• List est une interface qui définit les propriétés et les méthodes associées à une collection d'éléments ordonnés en lecture seule.
• MutableList étend l'interface List en définissant des méthodes permettant de modifier une liste, par exemple en ajoutant et en supprimant des éléments.

Ces interfaces ne spécifient que les propriétés et méthodes pour List et/ou MutableList. C'est la classe qui les étendra pour déterminer comment chaque propriété et méthode seront implémentées. L'implémentation basée sur des tableaux, que nous avons décrite ci-dessus, est celle que vous utiliserez la plupart du temps, voire tout le temps. Toutefois, Kotlin permet à d'autres classes d'étendre List et MutableList.

Fonction listOf()

Comme arrayOf(), la fonction listOf() utilise les éléments comme paramètres, mais renvoie un élément List au lieu d'un tableau.

1. Supprimez le code existant de l'élément main().
2. Dans main(), créez un élément List contenant la liste des planètes et dénommé solarSystem. Pour ce faire, appelez listOf().

fun main() {
    val solarSystem = listOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
}

3. List dispose d'une propriété size permettant d'obtenir le nombre d'éléments dans la liste. Imprimez la taille (size) de la liste solarSystem.

println(solarSystem.size)

4. Exécutez votre code. La taille de la liste doit correspondre à 8.

8

Accéder aux éléments d'une liste

Comme pour un tableau, vous pouvez accéder à un élément avec un indice spécifique à partir d'une propriété List à l'aide d'une syntaxe d'indice. Vous pouvez également utiliser la méthode get(). La syntaxe d'indice et la méthode get() utilisent Int comme paramètre et renvoient l'élément correspondant à cet indice. Comme Array, ArrayList utilise l'indexation zéro. Le quatrième élément a donc l'indice 3.

1. Imprimez la planète au niveau de l'indice 2 à l'aide d'une syntaxe d'indice.

println(solarSystem[2])

2. Imprimez l'élément au niveau de l'indice 3 en appelant get() dans la liste solarSystem.

println(solarSystem.get(3))

3. Exécutez votre code. L'élément dont l'indice correspond à 2 est "Earth" et l'élément dont l'indice correspond à 3 est "Mars".

...
Earth
Mars

En plus d'obtenir un élément via son indice, vous pouvez également rechercher l'indice d'un élément spécifique à l'aide de la méthode indexOf(). La méthode indexOf() recherche un élément donné dans la liste (transmis comme argument) et renvoie l'indice de la première occurrence de cet élément. Si l'élément ne figure pas dans la liste, il renvoie -1.

1. Imprimez le résultat de l'appel de indexOf() dans la liste solarSystem, en transmettant "Earth".

println(solarSystem.indexOf("Earth"))

2. Appelez indexOf(), en transmettant "Pluto", puis imprimez le résultat.

println(solarSystem.indexOf("Pluto"))

3. Exécutez votre code. Un élément correspond à "Earth". L'indice, 2, est donc imprimé. Aucun élément ne correspond à "Pluto". -1 est donc imprimé.

...
2
-1

Itérer des éléments de liste à l'aide d'une boucle for

Lorsque vous avez découvert les types de fonctions et les expressions lambda, vous avez vu comment utiliser la fonction repeat() pour exécuter du code plusieurs fois.

En programmation, il est courant d'effectuer une tâche une seule fois pour chaque élément d'une liste. Kotlin inclut une fonctionnalité appelée boucle for qui permet d'atteindre cet objectif avec une syntaxe concise et lisible. On parle souvent de lecture en boucle ou d'itération de liste.

Pour lire une liste en boucle, utilisez le mot clé for, suivi d'une parenthèse d'ouverture et d'une parenthèse de fermeture. Entre les parenthèses, indiquez un nom de variable, suivi du mot clé in, puis du nom de la collection. Après la parenthèse de fermeture, figurent une accolade d'ouverture et une accolade de fermeture, où vous inclurez le code que vous voulez exécuter pour chaque élément de la collection. C'est ce que l'on appelle le corps de la boucle. Chaque exécution de ce code est appelée une itération.

La variable située avant le mot clé in n'est pas déclarée avec val ni var. Elle est supposée être de type "get-only". Vous pouvez lui donner le nom que vous souhaitez. Si une liste porte un nom au pluriel, comme planets, il est courant de nommer la variable au singulier, par exemple planet. Il est également courant de nommer la variable item ou element.

Elle est utilisée en tant que variable temporaire correspondant à l'élément actuel de la collection (élément avec l'indice 0 pour la première itération, élément avec l'indice 1 pour la deuxième itération, et ainsi de suite) et est accessible entre les accolades.

Pour voir cela en pratique, vous devrez imprimer chaque nom de planète sur une ligne distincte à l'aide d'une boucle for.

1. Dans main(), sous l'appel println() le plus récent, ajoutez une boucle for. Entre les parenthèses, nommez la variable planet et lisez la liste solarSystem en boucle.

for (planet in solarSystem) {
}

2. Entre les accolades, imprimez la valeur planet à l'aide de println().

for (planet in solarSystem) {
    println(planet)
}

3. Exécutez votre code. Le code qui se trouve dans le corps de la boucle est exécuté pour chaque élément de la collection.

...
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Ajouter des éléments à une liste

L'ajout, la suppression et la mise à jour d'éléments dans une collection sont réservés aux classes qui implémentent l'interface MutableList. Si vous deviez effectuer le suivi des nouvelles planètes qui sont découvertes, vous auriez sans doute besoin de pouvoir ajouter fréquemment des éléments à une liste. Lorsque vous créez une liste à partir de laquelle vous souhaitez ajouter et supprimer des éléments, vous devez appeler spécifiquement la fonction mutableListOf() plutôt que listOf().

Il existe deux versions de la fonction add() :

• La première fonction add() comporte un seul paramètre correspondant au type d'élément de la liste et l'ajoute à la fin de cette dernière.
• L'autre version de add() comporte deux paramètres. Le premier paramètre correspond à un indice au niveau duquel le nouvel élément doit être inséré. Le deuxième paramètre correspond à l'élément ajouté à la liste.

Voyons les deux en action.

1. Modifiez l'initialisation de solarSystem de sorte à appeler mutableListOf() au lieu de listOf(). Vous pouvez maintenant appeler les méthodes définies dans MutableList.

val solarSystem = mutableListOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

2. Si vous souhaitez ajouter Pluton en tant que planète, appelez la méthode add() au niveau de solarSystem en transmettant "Pluto" comme argument unique.

solarSystem.add("Pluto")

3. Selon certains scientifiques, il existait une planète appelée Théia qui est entrée en collision avec la Terre et a formé la Lune. Insérez "Theia" au niveau de l'indice 3, entre "Earth" et "Mars".

solarSystem.add(3, "Theia")

Mettre à jour les éléments au niveau d'un indice spécifique

Vous pouvez mettre à jour des éléments existants à l'aide d'une syntaxe d'indice :

1. Remplacez la valeur avec l'indice "Future Moon" par 3.

solarSystem[3] = "Future Moon"

2. Imprimez la valeur au niveau des indices3 et 9 à l'aide d'une syntaxe d'indice.

println(solarSystem[3])
println(solarSystem[9])

3. Exécutez le code pour vérifier le résultat.

Future Moon
Pluto

Supprimer des éléments d'une liste

Les éléments sont supprimés à l'aide de la méthode remove() ou removeAt(). Vous pouvez supprimer un élément en le transmettant à la méthode remove() ou à l'aide de son indice avec removeAt().

Voyons en pratique les deux méthodes permettant de supprimer un élément.

1. Appelez removeAt() au niveau de solarSystem, en transmettant 9 pour l'indice. Cette action devrait supprimer "Pluto" de la liste.

solarSystem.removeAt(9)

2. Appelez remove() au niveau de solarSystem, puis transmettez "Future Moon" comme élément à supprimer. Cette action devrait lancer une recherche dans la liste. Si un élément correspondant est trouvé, il sera supprimé.

solarSystem.remove("Future Moon")

3. List fournit la méthode contains() qui renvoie une valeur Boolean si un élément existe dans une liste. Imprimez le résultat de l'appel de contains() pour "Pluto".

println(solarSystem.contains("Pluto"))

4. Une syntaxe encore plus concise consiste à utiliser l'opérateur in. Vous pouvez vérifier si un élément se trouve dans une liste à l'aide de l'élément, de l'opérateur in et de la collection. Utilisez l'opérateur in pour vérifier si solarSystem contient "Future Moon".

println("Future Moon" in solarSystem)

5. Exécutez votre code. Les deux instructions doivent imprimer false.

...
false
false

4. Ensembles

Un ensemble est une collection qui n'a pas d'ordre spécifique et qui n'accepte pas les valeurs en double.

Comment une collection de ce type est-elle possible ? Le secret réside dans un code de hachage. Un code de hachage est un élément Int généré par la méthode hashCode() d'une classe Kotlin. Il peut être considéré comme un identifiant semi-unique pour un objet Kotlin. Une légère modification de l'objet, par exemple l'ajout d'un caractère à une chaîne (String), entraîne une valeur de hachage très différente. Bien que deux objets puissent avoir le même code de hachage (on parle alors de "conflit de hachage"), la fonction hashCode() garantit un certain degré d'unicité : la plupart du temps, deux valeurs différentes ont un code de hachage unique.

Remarque : Un ensemble utilise des codes de hachage à la place d'indices de tableau. Comme il peut y avoir environ quatre milliards de codes de hachage différents, un ensemble (Set) n'est pas qu'un simple tableau géant. Un ensemble (Set) peut être considéré comme un tableau constitué de listes.

Le tableau externe est composé des nombres indiqués en bleu sur la gauche, qui correspondent chacun à une plage (également appelée "bucket") de codes de hachage possibles. Chaque liste interne (en vert à droite) représente les éléments individuels de l'ensemble. Étant donné que les conflits de hachage sont relativement rares, même lorsque les indices potentiels sont limités, les listes internes pour chaque indice du tableau ne comportent qu'un ou deux éléments, à moins que des dizaines ou des centaines de milliers d'éléments soient ajoutés.

Les ensembles présentent deux propriétés importantes :

1. La recherche d'un élément spécifique dans un ensemble est plus rapide que dans des listes, en particulier pour les collections volumineuses. L'élément indexOf() d'une liste (List) nécessite la vérification de chaque élément depuis le début jusqu'à ce qu'une correspondance soit trouvée. Toutefois, en moyenne, la vérification d'un élément dans un ensemble prend le même temps, qu'il s'agisse du premier élément ou du centième.
2. Les ensembles ont tendance à utiliser plus de mémoire que les listes pour la même quantité de données, car davantage d'indices de tableau sont souvent nécessaires par rapport aux données de l'ensemble.

Remarque : Contrairement aux idées reçues, le temps nécessaire pour vérifier si un ensemble contient un élément n'est pas fixe et dépend de la quantité de données qui s'y trouvent. Toutefois, comme il existe généralement peu de conflits de hachage, le nombre d'éléments à vérifier est toujours bien inférieur aux éléments d'une liste.

Les ensembles présentent l'avantage de garantir l'unicité. Si vous écriviez un programme pour effectuer le suivi des nouvelles planètes qui sont découvertes, un ensemble vous permettrait de vérifier facilement si une planète a déjà été découverte. Lorsque la quantité de données est importante, les ensembles sont souvent préférables aux listes, qui nécessitent de procéder à une itération sur tous les éléments lorsque vous y recherchez un élément.

Comme List et MutableList, il existe les aussi les propriétés Set et MutableSet. MutableSet implémente Set. Toute classe mettant en œuvre MutableSet doit donc implémenter les deux.

Utiliser une propriété MutableSet en Kotlin

Nous utiliserons MutableSet dans cet exemple pour montrer comment ajouter et supprimer des éléments.

1. Supprimez le code existant de l'élément main().
2. Créez un ensemble (Set) de planètes appelé solarSystem à l'aide de mutableSetOf(). Cela renverra un élément MutableSet, dont l'implémentation par défaut est LinkedHashSet().

val solarSystem = mutableSetOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

3. Imprimez la taille de l'ensemble à l'aide de la propriété size.

println(solarSystem.size)

4. Comme MutableList, MutableSet inclut une méthode add(). Ajoutez "Pluto" à l'ensemble solarSystem à l'aide de la méthode add(). Un seul paramètre est requis pour l'élément ajouté. Les éléments des ensembles n'ont pas nécessairement d'ordre spécifique. Ils ne sont donc pas associés à un indice.

solarSystem.add("Pluto")

5. Imprimez la taille (size) de l'ensemble après avoir ajouté l'élément.

println(solarSystem.size)

6. La fonction contains() utilise un seul paramètre et vérifie si l'élément spécifié fait partie de l'ensemble. Si tel est le cas, la valeur renvoyée est "true". Dans le cas contraire, la valeur "false" est renvoyée. Appelez contains() pour vérifier si "Pluto" se trouve dans solarSystem.

println(solarSystem.contains("Pluto"))

7. Exécutez votre code. La taille a augmenté, et contains() renvoie désormais true.

8
9
true

Remarque : Vous pouvez également utiliser l'opérateur in pour vérifier si un élément se trouve dans une collection. Par exemple, "Pluto" in solarSystem équivaut à solarSystem.contains("Pluto").

8. Comme indiqué précédemment, les ensembles ne peuvent pas contenir de doublons. Réessayez d'ajouter "Pluto".

solarSystem.add("Pluto")

9. Imprimez à nouveau la taille de l'ensemble.

println(solarSystem.size)

10. Exécutez à nouveau le code. "Pluto" n'a pas été ajouté, car il fait déjà partie de l'ensemble. La taille ne devrait pas augmenter cette fois.

...
9

La fonction remove() utilise un seul paramètre et supprime l'élément spécifié de l'ensemble.

1. Utilisez la fonction remove() pour supprimer "Pluto".

solarSystem.remove("Pluto")

Remarque : N'oubliez pas que les ensembles sont des collections non ordonnées. Il n'existe aucun moyen de supprimer une valeur d'un ensemble par son indice, car les ensembles ne comportent pas d'indice.

2. Imprimez la taille de la collection, puis appelez de nouveau contains() pour vérifier si "Pluto" se trouve toujours dans l'ensemble.

println(solarSystem.size)
println(solarSystem.contains("Pluto"))

3. Exécutez votre code. "Pluto" ne figure plus dans l'ensemble, et sa taille est désormais de 8.

...
8
false

5. Collection de mappages

Un mappage (Map) est une collection composée de clés et de valeurs. On parle de mappage, car des clés uniques sont mises en correspondance avec d'autres valeurs. Une clé et sa valeur associée sont souvent appelées key-value pair.

Les clés d'un mappage sont uniques. En revanche, ses valeurs ne le sont pas. Deux clés différentes peuvent être mises en correspondance avec la même valeur. Par exemple, "Mercury" a 0 lune, et "Venus" a 0 lune aussi.

Il est généralement plus rapide d'accéder à une valeur à partir d'un mappage que d'effectuer une recherche dans une longue liste, avec indexOf() par exemple.

Les mappages peuvent être déclarés à l'aide de la fonction mapOf() ou mutableMapOf(). Ils nécessitent deux types génériques séparés par une virgule : un pour les clés et un autre pour les valeurs.

Un mappage peut également utiliser l'inférence de type s'il existe des valeurs initiales. Pour remplir un mappage avec des valeurs initiales, chaque paire clé/valeur sera composée de la clé, suivie de l'opérateur to, suivie de la valeur. Chaque paire est séparée par une virgule.

Voyons de plus près comment utiliser les mappages, ainsi que certaines propriétés et méthodes utiles.

1. Supprimez le code existant de l'élément main().
2. Créez un mappage appelé solarSystem via mutableMapOf() avec les valeurs initiales, comme illustré ci-dessous.

val solarSystem = mutableMapOf(
    "Mercury" to 0,
    "Venus" to 0,
    "Earth" to 1,
    "Mars" to 2,
    "Jupiter" to 79,
    "Saturn" to 82,
    "Uranus" to 27,
    "Neptune" to 14
)

3. Comme pour les listes et les ensembles, Map fournit une propriété size contenant le nombre de paires clé/valeur. Imprimez la taille du mappage solarSystem.

println(solarSystem.size)

4. Vous pouvez utiliser une syntaxe d'indice pour définir des paires clé/valeur supplémentaires. Définissez la clé "Pluto" sur la valeur 5.

solarSystem["Pluto"] = 5

5. Imprimez à nouveau la taille après avoir inséré l'élément.

println(solarSystem.size)

6. Vous pouvez utiliser une syntaxe d'indice pour obtenir une valeur. Imprimez le nombre de lunes correspondant à la clé "Pluto".

println(solarSystem["Pluto"])

7. Vous pouvez également accéder aux valeurs avec la méthode get(). Que vous utilisiez la syntaxe d'indice ou que vous appeliez get(), il est possible que la clé que vous transmettez ne figure pas dans le mappage. En l'absence de paire clé/valeur, la valeur renvoyée est "null". Imprimez le nombre de lunes correspondant à "Theia".

println(solarSystem.get("Theia"))

8. Exécutez votre code. Le nombre de lunes pour Pluton devrait s'afficher. Cependant, comme Théia ne figure pas dans le mappage, l'appel de get() renvoie la valeur "null".

8
9
5
null

La méthode remove() supprime la paire clé-valeur avec la clé spécifiée. Elle renvoie également la valeur supprimée, ou null, si la clé spécifiée ne se trouve pas dans le mappage.

1. Imprimez le résultat en appelant remove() et en transmettant "Pluto".

solarSystem.remove("Pluto")

2. Pour vérifier que l'élément a été supprimé, imprimez à nouveau la taille.

println(solarSystem.size)

3. Exécutez votre code. Après la suppression de l'entrée, la taille du mappage est de 8.

...
8

4. La syntaxe d'indice, ou la méthode put(), peut également modifier une valeur pour une clé existante. Utilisez la syntaxe d'indice pour remplacer les lunes de Jupiter par 78 et imprimer la nouvelle valeur.

solarSystem["Jupiter"] = 78
println(solarSystem["Jupiter"])

5. Exécutez votre code. La valeur de la clé existante, "Jupiter", est mise à jour.

...
78

6. Conclusion

Félicitations ! Vous connaissez maintenant l'un des types de données les plus fondamentaux de la programmation, le tableau et plusieurs types de collections pratiques basés sur des tableaux, comme List, Set et Map. Ces types de collections permettent de regrouper et d'organiser les valeurs dans le code. Les tableaux et les listes permettent d'accéder rapidement aux éléments via leur indice, tandis que les ensembles et les mappages utilisent des codes de hachage pour faciliter la recherche d'éléments dans la collection. Ces types de collections seront souvent utilisés dans les applications futures. Leur utilisation vous sera utile dans votre carrière de programmeur.

Résumé

• Les tableaux stockent des données ordonnées de même type et ont une taille fixe.
• Les tableaux permettent d'implémenter de nombreux autres types de collections.
• Les listes sont des collections ordonnées redimensionnables.
• Les ensembles sont des collections non ordonnées et ne peuvent pas contenir de doublons.
• Les mappages fonctionnent de la même manière que les ensembles et stockent les paires de clés et de valeurs correspondant au type spécifié.

7. En savoir plus

• Collections
• Liste
• Conditions et boucles
• MutableList
• Ensemble
• hashCode()
• MutableSet
• Mappage
• MutableMap