Guide de tri à Kotlin

1. Vue d'ensemble

Kotlin s'appuie sur le framework Java Collection en utilisant des méthodes d'extension. Cela améliore considérablement la convivialité et la lisibilité sans avoir besoin de dépendances tierces telles que Apache Commons ou Guava.

Dans ce tutoriel, nous allons nous concentrer sur le tri dans Kotlin. Nous utiliserons également le package kotlin.comparisons pour implémenter des règles de tri complexes.

2. Tri d'une collection

Kotlin fournit plusieurs utilitaires pour faciliter le processus de tri des collections. Explorons plusieurs de ces méthodes.

2.1. Trier

Le moyen le plus simple de trier une collection consiste à appeler la méthode de tri . Cette méthode utilisera l'ordre naturel des éléments. De plus, il sera ordonné dans le sens ascendant par défaut, donc 'a' est avant 'b' et '1' avant '2':

val sortedValues = mutableListOf(1, 2, 7, 6, 5, 6) sortedValues.sort() println(sortedValues)

Et le résultat du code ci-dessus est:

[1, 2, 5, 6, 6, 7]

Il est important de noter que nous avons utilisé une collection mutable. La raison est que le genre méthode tri en place . Si nous voulons que le résultat soit renvoyé sous la forme d'une nouvelle liste, nous devons simplement utiliser la méthode triée à la place.

De plus, nous pouvons utiliser les méthodes sortDescending ou reverse pour trier dans un ordre décroissant .

2.2. Trier par

Si nous avons besoin de trier par propriétés spécifiques d'un objet donné, nous pouvons utiliser sortBy. La méthode sortBy nous permet de passer une fonction de sélection en argument. La fonction de sélection recevra l'objet et devrait renvoyer la valeur sur laquelle nous souhaitons trier:

val sortedValues = mutableListOf(1 to "a", 2 to "b", 7 to "c", 6 to "d", 5 to "c", 6 to "e") sortedValues.sortBy { it.second } println(sortedValues)

Et le résultat du code ci-dessus est:

[(1, a), (2, b), (7, c), (5, c), (6, d), (6, e)]

Encore une fois, la collection doit être modifiable car la méthode sortBy effectuera un tri sur place. Si nous voulons que le résultat soit renvoyé sous forme de nouvelle liste, nous devons utiliser la méthode sortedBy au lieu de la méthode sortBy .

Comme auparavant, par ordre décroissant, nous pouvons utiliser les méthodes sortByDescending ou reverse .

2.3. Trier avec

Pour une utilisation plus avancée (pour combiner plusieurs règles, par exemple), nous pouvons utiliser la méthode sortWith .

Nous pouvons passer un objet Comparator comme argument. Dans Kotlin, nous avons plusieurs façons de créer des objets Comparator et nous en parlerons dans la section suivante:

val sortedValues = mutableListOf(1 to "a", 2 to "b", 7 to "c", 6 to "d", 5 to "c", 6 to "e") sortedValues.sortWith(compareBy({it.second}, {it.first})) println(sortedValues)

Et le résultat du code ci-dessus est qu'ils sont triés par lettre puis par numéro:

[(1, a), (2, b), (5, c), (7, c), (6, d), (6, e)]

Comme sortWith effectuera le tri sur place, nous devons utiliser une collection mutable. Si nous voulons que le résultat soit renvoyé en tant que nouvelle collection, nous devons utiliser la méthode sortedWith au lieu de la méthode sortWith .

Pour l'ordre décroissant, nous pouvons utiliser la méthode inverse ou définir le bon comparateur .

3. Comparaison

Kotlin contient un package très utile pour construire un comparateur - kotlin.comparisons. Dans les sections suivantes, nous aborderons:

  • Création de comparateurs
  • Gestion des valeurs nulles
  • Inverser l'ordre
  • Extension des règles de comparaison

3.1. Création de comparateurs

Afin de simplifier la création de notre comparateur, Kotlin apporte de nombreuses méthodes d'usine pour rendre notre code plus expressif.

L' usine de comparateur la plus simple disponible est naturalOrder () . Aucun argument n'est nécessaire et l'ordre est croissant par défaut:

val ascComparator = naturalOrder()

Pour les objets avec plusieurs propriétés, nous pouvons utiliser la méthode compareBy . En arguments, nous donnons un nombre variable de fonctions (règles de tri) qui renverront chacune un objet Comparable . Ensuite, ces fonctions seront appelées séquentiellement jusqu'à ce que l' objet Comparable résultant soit évalué comme non égal ou jusqu'à ce que toutes les fonctions soient appelées.

Dans l'exemple suivant, it . La première valeur est utilisée pour les comparaisons et, seulement lorsque les valeurs sont égales, it.second sera appelée pour briser l'égalité:

val complexComparator = compareBy
    
     ({it.first}, {it.second})
    

N'hésitez pas à explorer kotlin.comparisons pour découvrir toutes les usines disponibles.

3.2. Gestion des valeurs nulles

Un moyen simple d'améliorer notre comparateur avec la gestion des valeurs nulles consiste à utiliser les méthodes nullsFirst ou nullsLast . Ces méthodes trieront les valeurs nulles à la première ou à la dernière place respectivement:

val sortedValues = mutableListOf(1 to "a", 2 to null, 7 to "c", 6 to "d", 5 to "c", 6 to "e") sortedValues.sortWith(nullsLast(compareBy { it.second })) println(sortedValues)

Le résultat du code ci-dessus sera:

[(1, a), (7, c), (5, c), (6, d), (6, e), (2, null)]

Nous pouvons voir que la dernière valeur de la collection résultante est celle avec une valeur nulle .

3.3. Inversion de l'ordre

To reverse the order, we can use the reverseOrder method or the reversed method. The former method has no arguments and returns a descending order. The latter method can be applied on a Comparator object and it will return its reversed Comparator object.

To build a Comparator using descending natural order we can do:

reverseOrder()

3.4. Comparator Rules Extension

Comparator objects can be combined or extended with additional sorting rules via the then methods available in kotlin.comparable package.

Only when the first comparator evaluates to equal, the second comparator will then be used.

Notre liste d'étudiants contient un âge et un nom pour chaque individu. Nous voulons qu'ils soient triés du plus jeune au plus âgé et, lorsqu'ils ont le même âge, décroissants en fonction du nom:

val students = mutableListOf(21 to "Helen", 21 to "Tom", 20 to "Jim") val ageComparator = compareBy
    
      {it.first} val ageAndNameComparator = ageComparator.thenByDescending {it.second} println(students.sortedWith(ageAndNameComparator))
    

Le résultat du code ci-dessus sera:

[(20, Jim), (21, Tom), (21, Helen)]

4. Conclusion

Dans ce rapide tutoriel, nous avons vu comment utiliser les méthodes sort , sortBy et sortWith pour trier les collections dans Kotlin.

Plus tard, nous avons également utilisé le package kotlin.comparisons pour créer des objets Comparator et les améliorer avec des règles de tri supplémentaires.

La mise en œuvre de tous ces exemples et extraits de code peut être trouvée sur GitHub.