Une brève discussion sur l'ordre du tableau ou de la liste des objets et des principes de tri des collections

Il est souvent nécessaire de trier les listes, à partir de la liste <string> pour trier les classes personnalisées. Pas besoin de fusionner ou de trier vous-même. Implémentez simplement une interface.

Cet article présentera d'abord l'utilisation des collections pour trier la liste <string> , puis parlera du principe de Collection.Sort.

Parlons de la façon de trier les cours personnalisés.

Enfin , une autre méthode de tri des objets personnalisés à l'aide de collections sera introduite, et les deux types sont une comparaison de performances simples.

1. Le principe de la liste de tri <String> et Collections.Sort

Le code est le suivant

 List <string> stringList = new ArrayList <string> (); StringList.add ("Nice"); StringList.add ("Delicious"); stringList.add ("capable"); StringList.add ("Moon"); stringList.add ("essai"); stringList.add ("ami"); Collection.Sort (StringList); pour (String str: stringList) {System.out.println (str); }

Où les collections sont java.util.collections.

Consultez la mise en œuvre du tri dans les collections

 @SuppressWarnings ("non contrôlé") public statique <T étend comparable <? super t >> void tri (list <t> list) {object [] array = list.toArray (); Arrays.sort (tableau); int i = 0; ListIterator <t> it = list.ListIterator (); while (it.hasnext ()) {it.next (); it.set ((t) array [i ++]); }}

À partir de cela, nous pouvons voir que le corps de tri est Arrays.sort (tableau); L'implémentation de tri des tableaux est

 public static void tri (objet [] array) {// begin Android-Changed ComparableTeMSort.sort (array); // terminer Android-Changed}

Continuez à suivre, la mise en œuvre de la comparaison de comparaison de comparaison ComparableTiTeTort.sort

STATIC VOID SORT (Object [] A) To static void Sort (Object [] A, int lo, int Hi) To Private Static void binarySort (Object [] A, int lo, int hi, int start). Dans BinarySort, la pièce utilisée pour la comparaison des tailles est

 Comparable <objet> pivot = (comparable) a [start]; int Left = lo; int droit = ​​start; affirmer à gauche <= à droite; while (gauche <droite) {int mid = (gauche + droit) >>> 1; if (pivot.compareto (a [mid]) <0) droit = ​​mid; else gauche = mid + 1; }

La comparaison de l'objet sera appelée à la comparaison. Par défaut, les types de chaînes et d'entiers ont été remplacés par la méthode compareto. Vous pouvez donc le comparer vous-même

2. Comparaison des classes personnalisées

Grâce à l'introduction ci-dessus, nous comprenons le principe du tri des collections. Ce qui suit est d'introduire le tri des objets personnalisés. Tout d'abord, vérifiez le principe de comparaison de l'entier et de la chaîne, puis introduisez comment comparer les classes personnalisées.

2.1 Nous avons vérifié la mise en œuvre de l'objet et constaté qu'il n'y a pas de méthode de comparaison.

Regardez la définition entière

 Le nombre final de classe finale étend le nombre de nombres implémentés par rapport à <Integer>

Regardons la définition de la chaîne

 La chaîne de classe finale publique implémente java.io.serializable, comparable <string>, charondence

Nous pouvons constater qu'ils héritent tous de comparables

2.2 Voir l'interface comparable

Vous pouvez constater qu'il n'y a qu'une seule méthode en comparable

Code java

 public int compareto (t o);

En d'autres termes, la méthode BinarySort appelle en fait la méthode de comparaison comparable, de manière à savoir que tant qu'elle est héritée de comparable,

Et implémenter Compareto pour appeler Collection.Sort pour trier les objets personnalisés

2.3 Comparaison des classes personnalisées

Le code suivant consiste à trier l'utilisateur. Tout d'abord, triez par nom un par un. Si les noms sont les mêmes, triez de petit à grand par âge.

Code java

 classe publique MAINTEST {public static void main (String [] args) {list <utilisateur> userList = new ArrayList <User> (); userList.add (nouvel utilisateur ("Lucy", 19)); userList.add (nouvel utilisateur ("jack", 19)); userList.add (nouvel utilisateur ("Jim", 19)); userList.add (nouvel utilisateur ("James", 19)); userList.add (nouvel utilisateur ("Herry", 19)); userList.add (nouvel utilisateur ("Luccy", 19)); userList.add (nouvel utilisateur ("James", 18)); userList.add (nouvel utilisateur ("Herry", 20)); Collection.Sort (UserList); pour (utilisateur utilisateur: userList) {System.out.println (user.getName () + "/ t / t" + user.getage ()); }} La classe statique privée utilisateur implémente le nom de la chaîne comparable <utilisateur; Âge privé; Utilisateur public (nom de chaîne, int age) {this.name = name; this.age = âge; } @Override public int compareto (user autre) {int compareName = this.name ........ if (compareName == 0) {return (this.age == Another.getAge ()? 0: (this.age> Another.getage ()? 1: -1)); } return comparename; } public String getName () {Nom de retour; } public int getage () {return âge; }}}

Après l'exécution, la sortie est:

Code XML:

 Herry 19 Herry 20 Jack 19 James 18 James 19 Jim 19 Luccy 19 Lucy 19

On peut voir que seuls deux points sont nécessaires

un. Hérité de comparable

Code java

 L'utilisateur de classe statique privée implémente un <utilisateur comparable

né Implémentez la méthode compareto

Le public Int compareto (User un autre) est le sujet de comparaison

Vous pouvez voir que int comparename = this.name.compareto (Another.getName ()); signifie le nom de comparaison

S'il est supérieur ou renvoyé 1, il est égal à retourner 0, et s'il est inférieur, il reviendra -1 .

S'il est égal, comparez-vous en fonction de la taille de l'âge int.

Ce qui précède est supérieur ou égal au retour 1, et ce qui précède est inférieur à celle -1, ce qui est également la base de la comparaison de binaires.

3. Utilisez la fonction surchargée des collections Tri pour trier les objets personnalisés

Le code est le suivant, et les noms sont toujours comparés en premier, s'ils sont égaux, alors la sortie de l'âge est comparée

Code java

 classe publique MAINTEST {public static void main (String [] args) {list <utilisateur> userList = new ArrayList <User> (); userList.add (nouvel utilisateur ("Lucy", 19)); userList.add (nouvel utilisateur ("jack", 19)); userList.add (nouvel utilisateur ("Jim", 19)); userList.add (nouvel utilisateur ("James", 19)); userList.add (nouvel utilisateur ("Herry", 19)); userList.add (nouvel utilisateur ("Luccy", 19)); userList.add (nouvel utilisateur ("James", 18)); userList.add (nouvel utilisateur ("Herry", 20)); CollectionS.Sort (UserList, nouveau comparateur <server> () {public int compare (user user1, user user2) {int compareName = user1.getName (). CompareTo (user2.getName ()); if (comparename == 0) {return (user1.getage () == user2.getage ()? compareName;}}); pour (utilisateur utilisateur: userList) {System.out.println (user.getName () + "/ t / t" + user.getage ()); }} classe statique privée utilisateur {nom de chaîne privée; Âge privé; Utilisateur public (nom de chaîne, int age) {this.name = name; this.age = âge; } public String getName () {Nom de retour; } public int getage () {return âge; }}}

Tu peux voir ça

Code java

 CollectionS.Sort (UserList, nouveau comparateur <server> ())

Il fait l'objet de comparaison et met en œuvre la méthode de comparaison du comparateur. Ce qui suit est le principe de cette méthode

Collections de piste

Code java

 Sort public STATIC <T> VOID (Liste <T> Liste, Comparateur <? Super T> C)

arriver

Code java

 Public Static <T> Void Sort (T [] A, Comparator <? Super T> C)

arriver

Code java

 STATIQUE VOID MERGESTort privé (objet [] src, objet [] dest, int low, int high, int off, comparateur c)

Vous pouvez trouver le code comme suit:

Code java

 if (length <insertionsort_threshold) {for (int i = low; i <high; i ++) for (int j = i; j> low && c ........... censel (dest [j-1], dest [j])> 0; j--) swap (dest, j, j-1); retour; }

Méthode de comparaison du comparateur d'appels

4. Comparaison des deux performances de tri ci-dessus

BinarySort doit effectuer des comparaisons NLG (n) , et au pire, n ^ 2 mouvements

Mergesort exécute constamment des divisions binaires, et après que les divisions binaires soient divisées en petites parties, elle est insérée et triée. Ainsi, les temps NLG (n) seront comparés et les temps NLG (n) seront déplacés . Mais il doit d'abord copier une copie des données source, donc elle prendra deux fois dans l'espace

Afin que vous puissiez choisir en fonction de vos besoins

L'article ci-dessus discute brièvement de l'ordre des tableaux ou des listes d'objets et les principes de tri des collections sont tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.