Tri des tableaux en Java

1. Vue d'ensemble

Dans ce didacticiel, nous aborderons les méthodes courantes pour trier les tableaux par ordre croissant et décroissant.

Nous examinerons l'utilisation de la méthode de tri de classe Arrays de Java ainsi que l'implémentation de notre propre comparateur pour ordonner les valeurs de nos tableaux.

2. Définitions d'objets

Avant de commencer, définissons rapidement quelques tableaux que nous allons trier tout au long de ce tutoriel. Tout d'abord, nous allons créer un tableau d' entiers et un tableau de chaînes:

int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 }; String[] strings = new String[] { "learning", "java", "with", "baeldung" };

Et créons également un tableau d' objets Employé où chaque employé a un identifiant et un attribut de nom :

Employee john = new Employee(6, "John"); Employee mary = new Employee(3, "Mary"); Employee david = new Employee(4, "David"); Employee[] employees = new Employee[] { john, mary, david };

3. Tri par ordre croissant

La méthode util.Arrays.sort de Java nous fournit un moyen rapide et simple de trier un tableau de primitives ou d'objets qui implémentent l' interface Comparable dans l'ordre croissant.

Lors du tri des primitives, la méthode Arrays.sort utilise une implémentation Dual-Pivot de Quicksort. Cependant, lors du tri d'objets, une implémentation itérative de MergeSort est utilisée.

3.1. Primitifs

Pour trier un tableau primitif par ordre croissant, nous passons notre tableau à la méthode de tri :

Arrays.sort(numbers); assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers); 

3.2. Objets qui implémentent comparable

Pour les objets qui implémentent l' interface Comparable , comme avec notre tableau primitif, nous pouvons également simplement passer notre tableau à la méthode de tri :

Arrays.sort(strings); assertArrayEquals(new String[] { "baeldung", "java", "learning", "with" }, strings);

3.3. Objets qui n'implémentent pas comparables

Le tri des objets qui n'implémentent pas l' interface comparable , comme notre tableau d' employés , nous oblige à spécifier notre propre comparateur.

Nous pouvons le faire très facilement dans Java 8 en spécifiant la propriété sur laquelle nous souhaitons comparer nos objets Employee dans notre comparateur:

Arrays.sort(employees, Comparator.comparing(Employee::getName)); assertArrayEquals(new Employee[] { david, john, mary }, employees);

Dans ce cas, nous avons précisé que nous souhaitons classer nos employés par leurs attributs de nom .

Nous pouvons également trier nos objets sur plus d'un attribut en chaînant nos comparaisons à l'aide de la méthode thenComparing de Comparator :

Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));

4. Tri par ordre décroissant

4.1. Primitifs

Le tri d'un tableau primitif par ordre décroissant n'est pas aussi simple que le tri par ordre croissant car Java ne prend pas en charge l'utilisation de comparateurs sur les types primitifs. Pour surmonter ce déficit, nous avons quelques options.

Tout d'abord, nous pourrions trier notre tableau dans l'ordre croissant, puis effectuer une inversion sur place du tableau.

Deuxièmement, nous pourrions convertir notre tableau en liste, utiliser la méthode Lists.reverse () de Guava, puis reconvertir notre liste en un tableau.

Enfin, nous pourrions transformer notre tableau en un Stream , puis le mapper à un tableau int . Il a l'avantage d'être une ligne unique et d'utiliser simplement le noyau Java:

numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray(); assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);

La raison pour laquelle cela fonctionne est que boxed transforme chaque int en un entier , ce qui implémente Comparator.

4.2. Objets qui implémentent comparable

Le tri d'un tableau d'objets qui implémente l' interface Comparable dans l'ordre décroissant est assez simple. Tout ce que nous devons faire est de passer un comparateur comme deuxième paramètre de notre méthode de tri .

En Java 8, nous pouvons utiliser Comparator.reverseOrder () pour indiquer que nous souhaitons que notre tableau soit trié par ordre décroissant:

Arrays.sort(strings, Comparator.reverseOrder()); assertArrayEquals(new String[] { "with", "learning", "java", "baeldung" }, strings);

4.3. Objets qui n'implémentent pas comparables

De la même manière que le tri des objets qui implémentent des comparables, nous pouvons inverser l'ordre de notre comparateur personnalisé en ajoutant reverse () à la fin de notre définition de comparaison:

Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed()); assertArrayEquals(new Employee[] { mary, john, david }, employees);

5. Conclusion

Dans cet article, nous avons expliqué comment trier les tableaux de primitives et d'objets dans l'ordre croissant et décroissant à l'aide de la méthode Arrays.sort .

Comme d'habitude, le code source de cet article est disponible sur Github.