TOC

Tri des tableaux en Java

Tri des tableaux en Java

1. Vue d'ensemble

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

Nous allons essayer d'utiliser la méthode de tri de classeArrays de Java ainsi que d'implémenter nos propresComparator pour ordonner les valeurs de nos tableaux.

2. Définitions d'objet

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

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

Et créons également un tableau deEmployee objects où chaque employé a unid and aname attribute: 

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éthodeutil.Arrays.sort de Java nous fournit un moyen rapide et simple de trier un tableau de primitives ou d’objets qui implémentent l’interfaceComparable dans l’ordre croissant.

Lors du tri des primitives, la méthodeArrays.sort utilise une implémentation Dual-Pivot deQuicksort. Cependant, lors du tri d'objets, une implémentation itérative deMergeSort est utilisée.

3.1. Primitives

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

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 la sinterfaceComparable , comme avec notre tableau primitif, nous pouvons aussi simplement passer notre tableau à la méthodesort: 

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

3.3. Objets qui n'implémentent pas comparables

Le tri des objets qui n’implémentent pas l’interfaceComparable , comme notre tableau deEmployees, 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 aimerions comparer nosEmployee objects dans nosComparator: 

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 en fonction de leursname attributs.

Nous pouvons également trier nos objets sur plus d'un attribut en chaînant nos comparaisons à l'aide deComparator’s thenComparing method: 

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

4. Tri par ordre décroissant

4.1. Primitives

Trier un tableau primitif par ordre décroissant n’est pas aussi simple que de le trier par ordre croissant car Java ne prend pas en charge l’utilisation des types primitifsComparators fils. Pour combler ce manque, nous avons quelques options.

Tout d'abord, nous pourrionssort our array in ascending order and then do an in-place reversal du tableau.

Deuxièmement, nous pourrions convertir notre tableau en une liste,use Guava’s Lists.reverse() method, puis reconvertir notre liste en tableau.

Enfin, nous pourrions transformer notre tableau en un sableStream puis le mapper à un tableauint. Il a un bel avantage d'êtrea one-liner and just using core 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 queboxed transforme chaqueint en unInteger, quedoes implémenteComparator.

4.2. Objets qui implémentent comparable

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

Dans Java 8, nous pouvons utiliserComparator.reverseOrder() t 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", "example" }, 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 notreComparator  personnalisé en ajoutantreversed() à 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éthodeArrays.sort.

Comme d'habitude, le code source de cet article peut être trouvéover on Github.

Related