• 12 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 13/11/2023

Itérez grâce aux boucles

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
Résultat de votre itération avec intervalle à 4 valeurs
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
Résultat de votre itération avec intervalle à 3 valeurs

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
Résultat de votre boucle "for" améliorée
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
Résultat de votre boucle "for" améliorée

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.

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 boucle  for  permet de "sauter" des itérations.

  • Vous pouvez créer facilement des collections de données immuables grâce aux méthodes  listOf  et  setOf  .

Pour aller plus loin :

Maintenant que vous savez itérer grâce aux boucles, suivez-moi dans le chapitre suivant pour découvrir le Smart Cast !

Et si vous obteniez un diplôme OpenClassrooms ?
  • Formations jusqu’à 100 % financées
  • Date de début flexible
  • Projets professionnalisants
  • Mentorat individuel
Trouvez la formation et le financement faits pour vous
Exemple de certificat de réussite
Exemple de certificat de réussite