tri des collections Java ()

L'une des fonctions les plus courantes dont nous avons besoin en tant que développeurs traitant des données est le tri - en pouvant trier nos données, nous pouvons optimiser nos algorithmes pour qu'ils s'exécutent beaucoup plus rapidement et trouver les données dont ils ont besoin en une fraction du temps qu'ils prendrait autrement. Dans la leçon d'aujourd'hui, nous allons parler de Java Collections sort(). Comme expérience de réflexion rapide : imaginez que vous recherchez un nom dans la liste d'une université. Il peut y avoir des dizaines de milliers d'élèves dans cette école. Si la liste qui vous a été donnée n'était pas dans l'ordre alphabétique, vous devrez parcourir chaque page et regarder très attentivement pour vous assurer que vous n'avez sauté aucun nom nulle part, jusqu'à ce que vous trouviez enfin le nom que vous recherchez. Par contre, si le roster était alphabétique, non seulement faut-il être moins rigoureux dans sa recherche, mais vous pouvez facilement accéder à la section de la liste avec la même première lettre et continuer à parcourir les pages à grands pas jusqu'à ce que vous tombiez sur la personne que vous recherchiez. Plus vous travaillez avec des données, plus il est important que vous les utilisiez aussi efficacement et efficacement que possible. Dans cet article, nous verrons comment trier toute implémentation de List en Java (y compris ArrayList) à l'aide de la méthode de tri Collections.

Comment trier une ArrayList en Java à l'aide de la méthode de tri Java Collections

Parlons de la méthode Java Collections.sort. Le package java.util contient de nombreux utilitaires et packages utiles qui sont souvent utilisés par les développeurs, y compris ArrayList. Supposons que vous ayez le programme simple suivant :

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

Vous voulez pouvoir imprimer la liste des couleurs, mais par ordre alphabétique. Comment pourriez-vous faire cela ? Avec java.util.Collections, le tri est aussi simple qu'une simple ligne :

Collections.sort(colors);

Ta-da ! Votre liste de couleurs a maintenant été triée sur place. Si vous deviez imprimer la liste, telle quelle :

System.out.println(colors);

Ensuite, vous obtiendrez la sortie suivante :

[Blue, Green, Orange, Red]

C'était facile ? ! Il serait tout aussi simple d'utiliser Collections.sort() pour trier par ordre croissant une liste d'entiers, de flottants ou de tout autre type de données simple d'ailleurs. Et si vous vouliez trier par ordre décroissant ? Il y a certainement des cas où cela a du sens - imaginez que vous disposiez d'une liste de résultats de tests pour une certaine classe et que vous souhaitiez déterminer qui sont les meilleurs élèves. Il serait beaucoup plus logique de trier la liste par ordre décroissant (les scores les plus élevés en premier), de sorte que les réponses que vous recherchez se trouvent tout en haut. Heureusement, Collections.sort() est remplacé par un deuxième paramètre facultatif, qui vous permet de faire exactement ceci :

sort(List l, Comparator c)

Mais qu'est-ce qu'un comparateur ? Eh bien, un comparateur est simplement une fonction qui compare deux entrées et renvoie un nombre représentant l'entrée qui vient en premier. Si vous triez une ArrayList de types de données primitifs, Java Collections vous fournit déjà un comparateur reverseOrder(). Il peut s'appeler ainsi :

Collections.sort(colors, Collections.reverseOrder());

Désormais, les couleurs ont été triées à l'envers sur place, de sorte que si vous l'imprimiez, vous obtiendriez le résultat suivant :

[Red, Orange, Green, Blue]

Comment utiliser les collections pour trier les types de données non primitifs en Java

Jusqu'à présent, vous avez vu que le tri de ArrayLists de chaînes ou d'ints en Java à l'aide de la méthode Collections.sort() est aussi simple qu'une ligne de code. Mais souvent, vos ArrayLists stockeront des types de données non primitifs. Lorsque vous travaillez avec des données qui ont des attributs plus complexes, vous souhaiterez écrire des classes pour représenter ces objets et comment ils seront comparés les uns aux autres à l'aide de leurs attributs. Pour en explorer un exemple, reprenons l'exemple du tri d'une liste de couleurs, mais cette fois, au lieu de trier des chaînes, nous allons trier des objets Color. Notre classe Color de base pourrait ressembler à ceci :

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

Afin de rendre notre classe Color compatible avec Collections.sort(), afin que Collections puisse comprendre comment comparer et trier les objets Color, nous devons apporter deux petites modifications :

1. faire de Color un objet Comparable (ajouter implémente Comparable<Object>)
2. remplacer la méthode compareTo dans la classe (remplacer public int compareTo(Object o))

Avec ces modifications, notre classe ressemble maintenant à ceci :

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

Notez que la méthode compareTo de Color appelle simplement la méthode compareTo de String ; le tri se fera par ordre alphabétique. Si nous voulions trier par valeur rouge dans l'ordre croissant, par exemple, nous pourrions remplacer l'instruction return par return this.r - cr; (si nous voulions trier par valeur verte dans l'ordre décroissant, ce serait return cg - this.g;). Maintenant, si nous appelons

Collections.sort(colors);

sur une ArrayList de Colors plutôt que simplement sur Strings, cela fonctionnerait car Collections comprend comment comparer des objets Color. Si vous ne souhaitez pas que votre objet implémente Comparable<Object>, vous pouvez également écrire un comparateur pour votre classe et le transmettre à la méthode Collections.sort() à 2 paramètres. Un comparateur remplace une méthode public int compare(Object one, Object two) et la méthode Collections.sort() l'utilise pour comparer des objets lors du tri. Un exemple de comparateurs SortByName et SortByRed est implémenté ci-dessous :

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

Avec cela, vous pouvez maintenant appeler

Collections.sort(colors, new SortByName());

sans que la classe Color n'implémente réellement Comparable, et cela fonctionnera toujours. Parfois, vous verrez que cela se fait en ligne, en utilisant des fonctions lambda. Une fonction lambda est essentiellement une fonction sans nom que vous pouvez définir dans la ligne de code qui l'appelle. Ils sont utiles lorsque vous n'avez besoin d'appeler une fonction que pour une instance spécifique et que vous ne souhaitez pas définir une fonction entièrement distincte ailleurs. Le comparateur SortByName peut être défini en ligne, à l'aide d'une fonction lambda, comme ceci :

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

Comme vous l'avez peut-être deviné, (a, b) représente les paramètres des fonctions lambda (les deux objets à comparer). Le -> signifie que ce qui suit est une définition de fonction lambda. C'est à peu près ça! Vous avez maintenant vu les méthodes les plus populaires de tri des ArrayLists en Java à l'aide du package Collections.