S'il y a quelque chose qui n’a pas vraiment changé en Kotlin, c’est bien la façon d’itérer. Ce chapitre ne devrait donc pas trop vous déboussoler... ;)
Tant que faire se peut
Vous devez sûrement connaître l’itération while
en Java, utilisée pour parcourir une liste tant que la condition n’est pas respectée ?
// While
while (isARainyDay) {
System.out.println("I don't love rain...");
}
// Do While
do {
System.out.println("I don't love rain...");
} while (isARainyDay)
Eh bien, en Kotlin, nous avons exactement la même chose :
// While
while (isARainyDay) {
println("I don't love rain...")
}
// Do While
do {
println("I don't love rain...")
} while (isARainyDay)
Kotlin n’apportant aucune amélioration spéciale à cette manière d’itérer, nous la passerons rapidement. :)
Pour une fois…
Que celui qui n’a jamais utilisé la boucle for
en Java se lève. Personne ? Eh, c’est normal ! Nous avons normalement tous utilisé au moins une fois ce type d’itération :
List<String> names = Arrays.asList("Jake Wharton", "Joe Birch", "Robert Martin");
for (String name : names) {
System.out.println("This developer rocks: " + name);
}
En Kotlin, celle-ci est d’ailleurs devenue beaucoup plus lisible :
val names = listOf("Jake Wharton", "Joe Birch", "Robert Martin");
for (name in names) {
println("This developer rocks: $name");
}
La boucle for
s’utilise désormais sous la forme <item> in <elements>
. On retrouve cette syntaxe dans beaucoup de langages récents, en Swift, par exemple… ;)
De plus, si vous avez besoin d’un index à l’intérieur de votre boucle, Kotlin vous permet de réaliser cela de plusieurs façons :
for (i in names.indices) {
println("This developer with number $i rocks: ${names[i]}")
}
for ((index, value) in names.withIndex()) {
println("This developer with number $index rocks: $value")
}
En revanche, navré de décevoir les plus puritains d’entre vous, mais, en Kotlin, la fameuse boucle for
initialisant une variable dans ses paramètres et mettant à jour cette valeur lors de son itération n’existe plus… 😱
for(int i = 1; i <= 42; i++) {
System.out.println("I love this number: "+i);
}
En fait, ce type d’itération a été remplacée en Kotlin par quelque chose couvrant quasiment les mêmes besoins, à savoir les intervalles (ou "ranges", en anglais).
for (i in 1..42) {
println("I love this number: $i")
}
En Kotlin, un intervalle est toujours fermé et inclusif, c’est-à-dire que sa seconde valeur sera incluse dans l’itération :
for (i in 0..3) println(i)
Dans ce premier exemple, l'affichage des résultats commence à 0 et contient 4 valeurs, de 0 à 3. Ce qui donnera comme résultat :
![Résultat de votre itération avec intervalle à 4 valeurs : 0 1 2 3](https://user.oc-static.com/upload/2023/02/03/16754327185114_16553813277622_p2c2-2a.png)
for (i in 1..3) println(i)
Dans ce deuxième exemple, l'affichage des résultats commence à 1 et contient 3 valeurs. Ce qui donnera comme résultat :
![Résultat de votre itération avec intervalle à 3 valeurs : 1 2 3](https://user.oc-static.com/upload/2023/02/03/16754327409283_16553815043155_p2c2-2b.png)
Mais la boucle for
ne s’arrête pas là en Kotlin ! Elle vous permet de réaliser des actions… comment dire… un peu uniques ! :D
for (i in 10 downTo 1 step 2) {
println("Index is: $i")
}
![Le résultat de votre boucle s'affiche : Index is :10 Index is :8 Index is :6 Index is :4 Index is :2](https://user.oc-static.com/upload/2023/02/03/1675432783323_16553815817516_p2c2-3a.png)
for (i in 1..10 step 2) {
println("Index is: $i")
}
![Le résultat de votre boucle améliorée s'affiche : Index is :1 Index is :3 Index is :5 Index is :7 Index is :9](https://user.oc-static.com/upload/2023/02/03/16754328215526_16553816526062_p2c2-3b.png)
Dans ces deux exemples, nous avons itéré sur un intervalle de 10 éléments. Cependant, grâce au mot-clé step
, nous avons "sauté" à chaque fois 1 élément pour accéder directement à l'élément i+2
. Et enfin, vous aurez bien évidemment remarqué le mot-clé downTo
nous permettant d’itérer "à l’envers" sur un intervalle (ici de 10 à 1).
Une liste pour les gouverner tous…
… et dans les ténèbres, les lier. Houla, je m’égare ! :honte: En Kotlin, vous aurez la possibilité de créer très facilement des listes de valeurs afin de lier différentes données entre elles.
Nous allons ainsi pouvoir appeler les méthodes génériques suivantes :
listOf
: Permet de créer une liste d’éléments ordonnée et immuable.mutableListOf
: Permet de créer une liste d’éléments ordonnée et muable.setOf
: Permet de créer une liste d’éléments désordonnée et immuable.mutableSetOf
: Permet de créer une liste d’éléments désordonnée et muable.
Euh, quelle est la différence entre list
et set
, déjà ? :euh:
Une liste de type list
contiendra des éléments uniques et/ou différents de manière ordonnée. Ses éléments seront accessibles grâce à un index. À l’inverse, une liste de type set
contiendra des éléments uniques et distincts de manière non ordonnée.
En pratique, voici ce que cela peut donner :
// listOf
val listOfNames = listOf("Jake Wharton", "Joe Birch", "Robert Martin")
listOfNames[0] // => Jake Wharton
listOfNames[0] = "Mathieu Nebra" // => ERROR! List is immutable
// mutableListOf
val listOfNames = mutableListOf("Jake Wharton", "Joe Birch", "Robert Martin")
listOfNames[0] // => Jake Wharton
listOfNames[0] = "Mathieu Nebra" // => SUCCESS!
// setOf
val setOfNames = setOf("Jake Wharton", "Joe Birch", "Robert Martin")
listOfNames.first() // => Jake Wharton
listOfNames.add("Mathieu Nebra") // => ERROR! Set is immutable
// mutableSetOf
val setOfNames = mutableSetOf("Jake Wharton", "Joe Birch", "Robert Martin")
listOfNames.first() // => Jake Wharton
listOfNames.add("Mathieu Nebra") // => SUCCESS!
Practice Makes Perfect!
La théorie, c'est bien, mais la pratique, c'est encore mieux ! Justement, nous vous avons concocté un petit exercice interactif de fin de chapitre pour appliquer toutes ces nouvelles connaissances.
🎓Un petit exercice, ça vous tente ? C'est par ici que ça se passe.
🎁Déjà terminé ? Le corrigé se trouve juste ici.
En résumé
En Kotlin, la syntaxe pour écrire une itération
while
ne diffère pas de son homologue Java.La boucle
for
s’utilise désormais sous la forme<item> in <elements>
.Vous pouvez utiliser des intervalles en Kotlin afin de créer une plage de données à parcourir (
1..10
signifie une plage de 1 à 10 inclus).Le mot-clé
step
dans une bouclefor
permet de "sauter" des itérations.Vous pouvez créer facilement des collections de données immuables grâce aux méthodes
listOf
etsetOf
.
Pour aller plus loin :
KotlinLang : Control Flow, Collections, Ranges
Maintenant que vous savez itérer grâce aux boucles, suivez-moi dans le chapitre suivant pour découvrir le Smart Cast !