Tutoriel sur le langage Kotlin

Tout d’abord, en Kotlin, les tableaux sont représentés par la classe générique Array : ainsi, on peut déclarer par exemple un Array<Int>, un Array<String>, voire un Array<Personne> (type personnel défini précédemment dans ce chapitre). Évidemment, un Array ne peut contenir que des valeurs d’un même type.

On peut construire un Array de deux manières différentes : soit par le constructeur Array, soit par la fonction arrayOf. La fonction arrayOf est plus proche de ce que l’on connaît en Java, tandis que le constructeur Array permet de bénéficier de plus de contrôle sur l’initialisation :

val tableau1 = arrayOf(2,10,-1,4,9)
val tableau2 = Array(10, { i -> i * 2 }) // utilisation d’une fonction lambda (fonction anonyme)
assert(tableau1[1] == 10) // on accède aux éléments comme en Java
tableau1[0] = 170
assert(tableau1[0] == 170) // de même pour la modification

Ici, j’utilise l’instruction assert dans un but purement illustratif : si l’expression passée en paramètre est fausse, une exception est lancée, sinon, il ne se passe rien de nouveau. C’est un moyen simple de montrer la valeur de la variable ainsi testée au lecteur.

Plusieurs remarques au sujet de l’initialisation via le constructeur :

• le premier paramètre décrit le nombre d’éléments du tableau ;
• le deuxième est une fonction qui prend l’index de l’élément à initialiser et qui retourne une valeur. J’ai utilisé une fonction anonyme pour la clarté du code, mais j’aurais aussi pu utiliser une fonction régulière. Même si nous verrons les fonctions ultérieurement, vous pouvez également remarquer qu’il s’agit d’une situation où l’on passe une fonction à une fonction (ici, la fonction anonyme au constructeur).

Rien ne nous empêche de déclarer des tableaux multidimensionnels, que ce soit par le biais du constructeur ou de la fonction arrayOf :

val tableau1 = arrayOf(arrayOf(1,2,3), arrayOf(4,5))
val tableau2 = Array(3, {i -> Array(3, {j -> i*j})})

Évidemment, les tableaux gardent une taille fixe.

Les tableaux disposent aussi de fonctions supplémentaires par rapport à leur version Java. Parmi la multitude de fonctionsla multitude de fonctions supplementaires pour Array, citons :

val tab = arrayOf(7,10,15,3,6,9,12)
tab.sum()
tab.sort()
tab.sorted() // idem que sort() mais se contente de retourner le resultat au lieu de modifier le tableau contenu dans tab
tab.reverse()
tab.reversed()
tab.min()
tab.max()
tab.first()
tab.last()
tab.take(3) // les 3 premiers éléments du tableau sans le modifier
tab.drop(3) // le tableau sans ses 3 premiers éléments sans le modifier

Les listes sont similaires aux tableaux, mais sont plus puissantes, du moins dans leur version modifiable. En effet, comme pour d’autres types de collections, il y a les listes immuables (non modifiables) et les listes modifiables. Tout dépend de la manière dont elles sont déclarées.

val maListeNonModifiable = listOf(1,2,3)
// interdit !!! maListeNonModifiable[2] = 6;
    
val maListeModifiable = mutableListOf(1,2,3)
maListeModifiable[2] = 6;
maListeModifiable += 10; // équivalent a maListeModifiable.add(10)
    
print(maListeModifiable) // => [1, 2, 6, 10]

Ainsi :

• on peut créer une liste immuable grâce à la fonction listOf(), et créer une liste modifiable par l’intermédiaire de la fonction mutableListOf(). Ces deux méthodes sont par ailleurs génériques, mais l’inférence de type nous permet d’éviter d’en déclarer le type ;
• vous pouvez constater que l’on ne peut pas modifier un élément d’un objet List, contrairement à un objet MutableList ;
• on peut facilement ajouter des éléments aux listes modifiables.

Pourquoi aurait-on alors intérêt à utiliser les listes non modifiables ? Par exemple, pour la création d’algorithmes. Et cela grâce à plusieurs mécanismes de la programmation fonctionnelle, rendus plus faciles avec l’immutabilité.

Parmi ces mécanismes, on peut citer la déconstruction: c’est-à-dire la reconnaissance d’une expression en tant que « schéma » et l’attribution dans des variables. Le tout étant effectué simultanément.

Nous reparlerons du mécanisme de déconstruction ultérieurement dans ce tutoriel.

Par ailleurs, rien ne nous empêche d’écrire ce qui suit, générant ainsi une liste immuable à partir d’une autre.

val maListeNonModifiable = listOf(1,2,3)   
    val maListe2 = maListeNonModifiable + 5 // maListeNonModifiable reste telle quelle.

Le type MutableList étant dérivé du type List, ils ont de nombreuses méthodes communes qui peuvent s’avérer très utiles. On peut notamment citer :

val maListeImmuable = listOf(1,2,3,4,5)
maListeImmuable.isEmpty() // est-elle vide ?
maListeImmuable.contains(2) // le chiffre 2 y figure-t-il ?
maListeImmuable.all({it % 2 == 0}) // ne contient que des chiffres pairs ?
maListeImmuable.chunked(2) // => [[1, 2], [3, 4], [5]]
maListeImmuable.count({it % 2 == 0}) // combien de chiffres pairs a-t-elle ?
maListeImmuable.take(3) // retourne une liste avec les 3 premiers éléments
maListeImmuable.drop(2) // retourne une liste sans les 2 premiers éléments

Certaines lignes du code précédent utilisent les lambdas, des fonctions anonymes que nous verrons ultérieurement.

N’hésitez pas à aller consulter les méthodes disponibles pour ListAPI pour le type List et MutableListAPI pour le type MutableList.

Kotlin supporte aussi les tables associatives : des collections qui associent leurs valeurs à des clés, appelées Map en anglais.

Comme pour les listes, il y a les tables associatives immuables (MapAPI table associative immuable) et les tables associatives modifiables (MutableMapAPI table associative modifiable), et on peut les instancier grâce aux fonctions mapOf() et mutableMapOf()

val monDictionnaireImmuable = mapOf("Sandra" to 27, "Alex" to 10)
val monDictionnaireModifiable = mutableMapOf("Sandra" to "0102030405", "Alex" to "0104050607")
    
monDictionnaireModifiable += ("Beatrice" to "0809101112")
monDictionnaireModifiable["Sandra"] = "0802030405"
val monDictionnaireImmuableEnrichi = monDictionnaireImmuable + ("Beatrice" to 30)

Elles disposent elles aussi de nombreuses méthodes qui peuvent vous simplifier le développement :

val monDictionnaireImmuable = mapOf("Sandra" to 27, "Alex" to 10)
    
monDictionnaireImmuable.getOrDefault("Beatrice", 33) // retourne l’âge de Beatrice ou 33 si elle ne figure pas dans la table
monDictionnaireImmuable.all({ it.value > 18 }) // indique si toutes les personnes de la table sont majeures
monDictionnaireImmuable.any({ it.key == "Sandra" }) // Sandra est-elle dans la table ?
monDictionnaireImmuable.contains("Sandra") // idem
monDictionnaireImmuable.filter({ it.value > 18 }) // retourne une table ne gardant que les personnes majeures (ne modifie pas la table originale)
monDictionnaireImmuable.map({ it.value - 10 }) // retourne la liste des âges des personnes, auxquels on aura retranché 10
monDictionnaireImmuable.count() // le nombre d’associations de la table

Encore une fois, n’hésitez pas à aller consulter les documentations officielles de ces deux classes (voir les liens que je vous ai donnés plus haut).

L’utilisation des Sets est elle aussi intuitive :

val mesPiecesCapturees = setOf("Cavalier", "Dame", "Fou")
val mesPiecesCaptureesV2 = mesPiecesCapturees - "Dame"
    
val mesComics = mutableSetOf("Spiderman", "Batman", "Superman")
mesComics += "Green Lantern"

Vous pouvez là aussi retrouver les API pour les classes SetAPI pour les Set immuables (immuable) et MutableSetAPI pour les Set modifiables (modifiable). Quelques méthodes parmi tant d’autres :

val mesPiecesCapturees = setOf("Cavalier", "Dame", "Fou")
mesPiecesCapturees.count() // nombre d’éléments
mesPiecesCapturees.filter{it.startsWith("C")} // filtre ne retenant que les éléments commençant par « C »;
mesPiecesCapturees.map{it.toLowerCase()} // set où les éléments ont été convertis en minuscules
mesPiecesCapturees.isEmpty() // est-il vide ?
mesPiecesCapturees.isNotEmpty() // a-t-il des éléments ?
mesPiecesCapturees.maxBy{it.length} // quel élément est le plus long ?

L’instruction while (ou do… while) en Kotlin, tout comme en Java, ne retourne pas d’expression. Elle s’utilise aussi comme en Java : rien de nouveau.

var i = 0
while (i < 10) {
  i += 1
  println(i)
}

var j = 0
do {
   j += 1
   println(j)
} while (j < 10)

Les mots-clés break et continue fonctionnent comme en Java.

L’instruction if peut être utilisée aussi bien en tant que structure de contrôle traditionnelle qu’en tant qu’expression. Voici les deux cas de figure en situation :

    if (1<2) {
        println("ok")
    }
    else if (2 != 2) {
        println("ko 1")
    }
    else {
        println("ko 2")
    }

Ça, c’est le cas de figure que nous connaissions déjà.

L’autre cas, c’est l’équivalent de l’opérateur ternaire de Java, sauf que cet opérateur n’existe pas en Kotlin, il a été remplacé par l’expression if-else.

val couleur = if (caseBlanche) "white" else "black"

Ceci nous évite de créer une variable temporaire et permet de créer directement une valeur immuable.

L’instruction for, quant à elle, ne peut pas être utilisée en tant qu’expression.

L’utilisation de l’instruction for telle qu’on la connaît en Java (initialisation/condition/mise à jour accompagnée d’un bloc d’instructions) est strictement interdite en Kotlin. En effet, on ne peut utiliser la boucle for que sur des objets « iterable » : traditionnellement des ranges ou certains types de collections. Par « iterable », je veux simplement parler de types pour lesquels on peut obtenir les différentes valeurs d’une variable de ce type par appels successifs à la méthode d’extraction (appelons-la next() pour mieux illustrer).

Ce qui peut par exemple donner :

// i n’existe pas dans cette portée
for (i in 0..10) println(i)

Remarquez bien ici qu’il ne faut utiliser ni le mot-clé val, ni var, afin de déclarer la variable i : peu importe qu’elle existe déjà ou non, il ne faut surtout pas les utiliser.

Un autre exemple avec un simple tableau :

val monTableau = arrayOf(2,3,5,7,11,13)
for (premier in monTableau) {
    println("$premier est un nombre premier")
}

Remarquez aussi que je peux m’affranchir des accolades si je n’ai besoin que d’une simple expression pour la boucle for (ce qui est donc possible dans ce deuxième exemple).

Enfin, si l’on souhaite parcourir un tableau tout en conservant les valeurs des différents index, on peut utilise la méthode withIndex() mais avec une syntaxe un peu particulière pour les variables d’index et de valeur :

val monTableau = arrayOf(2,3,5,7,11,13)
for ((index, valeur) in monTableau.withIndex()) {
   println("$index: $valeur")
}

Remarquez que la méthode withIndex() retourne une Pair où la première valeur est l’index, donc il faut empaqueter les variables d’index et de valeur entre parenthèses afin de procéder au mécanisme de déconstruction. Mais rien ne nous empêche de procéder en deux étapes :

val monTableau = arrayOf(2,3,5,7,11,13)
for (tupleCourant in monTableau.withIndex()) {
    val index = tupleCourant.component1()
    val valeur = tupleCourant.component2()
    println("$index: $valeur")
}

Bien évidemment, l’instruction for permet aussi de parcourir les tables associatives

val monRepertoireTel = mapOf("Bea" to "0123456789", "Lily" to "08123456", "Max" to "06123456")
    
for (entree in monRepertoireTel) {
    println("${entree.key} => ${entree.value}")
}
 
// Version utilisant la déconstruction   
for ((nom, numero) in monRepertoireTel) {
    println("$nom => $numero")
}

Tout comme pour les boucles while (do…while), les mots-clés break et continue fonctionnent comme en Java.

L’instruction est une instruction ultra puissante, basée sur une fonctionnalité communément appelée le « pattern-matching » dans un certain nombre de langages. C’est un concept plus ou moins lié au mécanisme de déconstruction que nous avons vu auparavant. D’ailleurs, avant de vous expliquer comment elle fonctionne et à quoi elle peut être utile, je tiens à vous préciser qu’en plus de sa puissance et sa flexibilité, l’instruction when est aussi une expression.

X-D-1. Cas ultra simple▲

fun main() {
    val a = 10;
    var signeDeA: Int;
      when {
        a < 0 -> println("negatif")
        a == 0 -> println("nul")
        else -> println("positif")
    }
}

fun main() {
    val a = 10;
    var signeDeA: Int;
      when {
        a < 0 -> println("negatif")
        a == 0 -> println("nul")
    }
}

fun main() {
    val a = 10;
    var signeDeA: Int;
      when {
        a > 0 -> println("positif")
        a == 0 -> println("nul")
        else -> println("negatif")
    }
}

X-D-2. Test en fonction d’une variable en entrée▲

fun main() {
    val de = java.util.Random()
    val valeurDe = de.nextInt(6) + 1
    val texteValeur = when (valeurDe)
    {
        1 -> "Un"
        2 -> "Deux"
        3 -> "Trois"
        4 -> "Quatre"
        5 -> "Cinq"
        else -> "Six"
    }
    println(texteValeur);
}

val de = java.util.Random()
val valeurDe = de.nextInt(6) + 1
println(when(valeurDe) {
   1 -> "Un"
   2 -> "Deux"
   3 -> "Trois"
   4 -> "Quatre"
   5 -> "Cinq"
   else -> "Six"
})

X-D-3. Pas d’obligation de tester des constantes▲

fun estPaire(texteValeur: String): Boolean {
    return when (texteValeur) {
        "Deux", "Quatre", "Six" -> true
        else -> false
    }
}

fun main(args: Array<String>) {
    val de = java.util.Random()
    val valeurDe = de.nextInt(6) + 1
    val texteValeur = when(valeurDe) {
       1 -> "Un"
       2 -> "Deux"
       3 -> "Trois"
       4 -> "Quatre"
       5 -> "Cinq"
       else -> "Six"
    }
        println(texteValeur)

    println(when {
        estPaire(texteValeur) -> "Paire"
        else -> "Impaire"
    })
}

X-D-4. Exécution de bloc▲

when (ageGuillaume) {
    estMineur(ageGuillaume) -> {
        println("Desole, le droit de vote est interdit aux mineurs")
        repousserGuillaumeALEntree()
        sermonerGuillaume()
    }
    else -> {
        println("Voici les bulletins de vote")
        indiquerIsoloirAGuillaume()
    }
}

X-D-5. Regrouper plusieurs valeurs de test▲

switch (a) {
case 2:
case 3:
case 5:
case 6: println("2,3,5 ou 6");
default: println("autre");
}

when (a) {
2, 3, 5, 6 -> println("2,3,5 ou 6")
else -> "autre"
}

when (age) {
   in 13..19 -> "adolescent"
   else -> "autre"
}

X-D-6. Test du type de données▲

when (age) {
   is String -> "Il faut traiter la valeur auparavant"
   is Int -> "Ok"
   else -> " Impossible d'exploiter cette valeur"
}

when (age) {
   is String -> println(age.length) // age est un String donc la propriété length existe
   is Int -> println(age.dec()) // affiche age - 1
   else -> println("Impossible d'exploiter cette valeur")

On peut utiliser les mots-clés is et !is pour respectivement tester si un type est ou n’est pas d’un type donné.

if (obj is String)
{
   // faire quelque chose
}

if (a!is Int)
{
   // faire quelque chose
}

Le mot-clé as permet d’effectuer une conversion de type.

val s:String = valeur as String

Mais si valeur est null, cela lèvera une exception. En effet, le type String ne peut pas prendre la valeur null, contrairement au type String? ; nous en reparlerons sous peu, ainsi que du mot-clé as?)

Tout d’abord, examinez le code suivant :

if (figureCourante is Cercle)
{
    println(figureCourante.rayon)
}
else if (figureCourante is Rectangle)
{
    println(figureCourante.largeur)
}

Admettons qu’au préalable, son auteur ait pris soin de définir une hiérarchie de figures (classe Figure), ainsi qu’une classe fille Cercle qui dispose de la propriété rayon, et une classe fille Rectangle qui n’en dispose pas. De même, la classe fille Rectangle dispose de la propriété largeur et pas la classe Cercle. Et donc la classe Figure ne dispose d’aucune de ces deux propriétés.

Ce qui peut choquer de prime abord avec le code ci-dessus, c’est que malgré le fait que figureCourante s’apparente à une instance de Figure, il n’y a pas de cast avant d’accéder aux propriétés rayon (de la classe fille Cercle) et largeur (de la classe fille Rectangle). Mais juste deux branches if-else.

Et pourtant, il s’agit bien d’une fonctionnalité de Kotlin :

• dans chaque test, il est sûr que la variable est d’un type donné
• donc inutile d’y effectuer un cast : il est assez intelligent pour réduire le champ des possibles à l’intérieur du if.

Qui plus est, nous avons vu plus haut une façon bien plus élégante de réaliser cela : when !

when (figureCourante) {
  is Cercle -> println(figureCourante.rayon)
  is Rectangle -> println(figureCourante.largeur)
  else -> println("Echec d'exploitation de la figure")
}

En Kotlin, il n’y a pas de conversion automatique des types numériques. Si l’on veut convertir un Int en Long, il faut passer par une méthode prévue à cet effet :

val a = 10.0 // a est un Double
val b = a.toLong()

val c = 10.0 as Int // la conversion automatique entre types numériques n’existe pas: une ClassCastException sera levée
val d = 10 as Long // de même

Les méthodes s’appellent simplement toInt(), toDouble(), toLong()… et font partie de l’API standard de Kotlin. (Vous pouvez toujours y accéder depuis le site officielRéférence officielle de la librairie standard.)