Initiez-vous à Kotlin

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.

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 :

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 :

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 !

for (i in 10 downTo 1 step 2) {
    println("Index is: $i")
}

for (i in 1..10 step 2) {
    println("Index is: $i")
}

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).

… et dans les ténèbres, les lier. Houla, je m’égare !  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.

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!

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 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  .

• 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 !