Selon l'accord, lorsque vous utilisez la programmation Java, vous devez utiliser autant que possible les bibliothèques de classes existantes. Bien sûr, vous pouvez également écrire vous-même une méthode ou un framework de tri, mais combien de personnes peuvent écrire mieux que celles du JDK ? Un autre avantage de l'utilisation des classes existantes est que le code est facile à lire et à maintenir. Cet article explique principalement comment utiliser les bibliothèques de classes existantes pour trier les tableaux et divers conteneurs de collection (certains exemples de l'article proviennent de "Java Developers Almanac 1.4》. )
Tout d'abord, vous devez connaître deux classes : java.util.Arrays et java.util.Collections (notez la différence avec Collection) Collection est l'interface de niveau supérieur du framework de collection et Collections contient de nombreuses méthodes statiques. Nous utilisons des tableaux pour trier les tableaux et des collections pour trier les conteneurs de cadres combinés, tels que ArraysList, LinkedList, etc.
Import java.util.* et d'autres codes shell, tels que les classes et les méthodes principales statiques, doivent être ajoutés aux exemples. J'écrirai tous les codes dans le premier exemple et les omettra sans exception dans ce qui suit.
Trier le tableau
Par exemple, il existe un tableau d'entiers :
Copiez le code comme suit :
int[] intArray = nouveau int[] {4, 1, 3, -23};
Comment fait-on le tri ? Pensez-vous à l’algorithme de tri rapide en ce moment ? Jetez un œil à comment cela se fait :
Copiez le code comme suit :
importer java.util.* ;
classe publique Trier{
public static void main (String[] args){
int[] intArray = nouveau int[] {4, 1, 3, -23};
Arrays.sort(intArray);
}
}
De cette façon, nous utilisons la méthode statique sort() de Arrays pour trier l'intArray par ordre croissant, et maintenant le tableau est devenu {-23,1,3,4}.
S'il s'agit d'un tableau de caractères :
Copiez le code comme suit :
String[] strArray = new String[] {"z", "a", "C"};
Nous utilisons :
Copiez le code comme suit :
Arrays.sort(strArray);
Le résultat après tri est {C, a, z} et sort() triera par ordre croissant selon l'ordre naturel des éléments. Si vous souhaitez ne pas respecter la casse, vous pouvez écrire :
Copiez le code comme suit :
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Bien sûr, nous pouvons également spécifier une certaine section du tableau à trier. Par exemple, si nous voulons trier les parties 0 à 2 du tableau (en supposant que la longueur du tableau est supérieure à 3) et que les autres parties restent inchangées, nous pouvons également spécifier une certaine section du tableau à trier. peut utiliser :
Copiez le code comme suit :
Arrays.sort(strArray,0,2);
De cette façon, nous trions uniquement les trois premiers éléments sans affecter les parties suivantes.
Bien sûr, certaines personnes se demanderont comment trier par ordre décroissant ? Parmi les nombreuses méthodes de tri, une copie du code est la suivante :
trier(T[] a, Comparateur<? super T> c)
Nous pouvons utiliser Comparator pour obtenir un comparateur dans l'ordre inverse. Comparator sera expliqué plus tard. Prenons l'exemple de intArray[] :
Copiez le code comme suit :
Arrays.sort(intArray,Comparator.reverseOrder());
De cette façon, le résultat que nous obtenons est {4,3,1,-23}. Si nous ne voulons pas modifier le code original, nous pouvons également utiliser :
Copiez le code comme suit :
Collections.reverse(Arrays.asList(intArray));
Obtenez l'ordre inverse du tableau. Le résultat est également 4,3,1,-23}.
Maintenant, la situation a changé. Notre tableau n'est plus un tableau de type de données primitif (type primitif) ou de type String, mais un tableau d'objets. L'ordre naturel de ce tableau est inconnu, nous devons donc implémenter l'interface Comparable pour cette classe. Par exemple, nous avons une classe Name :
Copiez le code comme suit :
le nom de la classe implémente Comparable<Name>{
public String firstName,lastName;
Nom public (String firstName, String lastName) {
this.firstName=firstName;
this.lastName=lastName;
}
public int compareTo(Name o) { // Implémenter l'interface
int lastCmp=lastName.compareTo(o.lastName);
return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));
}
public String toString(){ //Pratique pour les tests de sortie
return firstName+" "+lastName;
}
}
De cette façon, lorsque nous trierons ce tableau d'objets, nous comparerons d'abord lastName, puis comparerons firstName, puis obtiendrons l'ordre des deux objets, tout comme ce qui est implémenté dans compareTo(Name o). Autant essayer avec le programme :
Copiez le code comme suit :
importer java.util.* ;
classe publique NomSort {
public static void main (String[] arguments) {
Nom nameArray[] = {
nouveau nom("John", "Lennon"),
nouveau nom("Karl", "Marx"),
nouveau nom("Groucho", "Marx"),
nouveau nom("Oscar", "Grouch")
} ;
Arrays.sort(nomArray);
pour(int i=0;i<nameArray.length;i++){
System.out.println(nameArray[i].toString());
}
}
}
Le résultat est tel que nous l’espérions :
Copiez le code comme suit :
Oscar Grouch
John Lennon
Groucho Marx
Karl Marx
Trier les cadres de collection
Si vous avez compris Arrays.sort() pour trier les tableaux, l'utilisation du framework de collection est similaire. Remplacez simplement Arrays par Collections. Notez que Collections est une classe et Collection est une interface. Bien qu'il n'y ait qu'une seule différence "s", leurs significations sont complètement différentes.
Supposons qu'il existe une telle liste chaînée :
Copiez le code comme suit :
LinkedList list=nouvelle LinkedList();
list.add(4);
list.add(34);
list.add(22);
list.add(2);
Il suffit d'utiliser :
Copiez le code comme suit :
Collections.sort(liste);
Vous pouvez trier les éléments de ll de petit à grand, et le résultat devient :
Copiez le code comme suit :
[2, 4, 22, 34]
Si les éléments de LinkedList sont des chaînes, ils seront également triés du plus petit au plus grand comme les types de données de base.
Si vous souhaitez mettre en place un tri inversé, c'est-à-dire du tri par atteinte au tri petit :
Copiez le code comme suit :
Collections.sort(liste,Collectons.reverseOrder());
Si les éléments de LinkedList sont des objets personnalisés, vous pouvez implémenter l'interface Comparable comme l'objet Name ci-dessus, puis laisser Collection.sort() les trier pour vous.
Si vous souhaitez trier un objet selon vos propres idées, vous pouvez utiliser le code copié comme suit :
trier(Liste<T> liste, Comparateur<? super T> c)
Cette méthode effectue un tri Avant de donner un exemple, il faut d'abord expliquer l'utilisation de Comparator et le format de l'interface Comparable :
Copiez le code comme suit :
interface publique Comparateur<T> {
int comparer(T o1, T o2);
}
En fait, la méthode d'écriture de int compare(T o1,T o2) dans Comparator est similaire à la méthode d'écriture de la méthode compareTo() dans Comparable. Dans la classe Name ci-dessus, notre comparaison part de LastName. C'est l'habitude des Occidentaux, nous voulons commencer la comparaison à partir de firstName sans modifier le code d'origine.
Copiez le code comme suit :
final Comparator<Nom> FIRST_NAME_ORDER=new Comparator<Nom>() {
public int comparer (Nom n1, Nom n2) {
int firstCmp=n1.firstName.compareTo(n2.firstName);
retourner (firstCmp!=0?firstCmp:n1.lastName.compareTo
(n2.premierNom));
}
} ;
De cette façon, notre comparateur personnalisé FIRST_NAME_ORDER est écrit.
Convertissez le tableau de noms de l'exemple précédent en une liste :
Copiez le code comme suit :
List<Nom> list=Arrays.asList(nameArray);
Collections.sort(liste,FIRST_NAME_ORDER);
De cette façon, nous avons réussi à définir le tri à l’aide de notre propre comparateur défini.