Comparable
Comparable est l'interface de tri.
Si une classe implémente l'interface comparable, cela signifie "cette classe prend en charge le tri". Étant donné que les classes qui implémentent l'interface comparable prennent en charge le tri, en supposant qu'il existe désormais une "liste de liste (ou un tableau) d'objets de classes qui implémentent une interface comparable", la liste de liste (ou le tableau) peut être triée par Collection.sort (ou Arrays.sort).
De plus, "l'objet de la classe qui implémente l'interface comparable" peut être utilisé comme clé dans une "carte ordonnée (comme Treemap)" ou un élément dans un "ensemble ordonné (arreset)" sans spécifier un comparateur.
L'interface comparable ne comprend qu'une seule fonction, et sa définition est la suivante:
package java.lang; import java.util. *; interface publique comparable <T> {public int compareto (t o);} Description: Supposons que nous «comparez les tailles de x et y» via x ..compareto (y). Si vous retournez un "nombre négatif", cela signifie "x est plus petit que y"; Si vous retournez un "zéro", cela signifie "x est égal à Y"; Si vous retournez un "nombre positif", cela signifie "x est supérieur à Y".
L'interface comparable a été générique, donc l'objet qui implémente comparable déclare à quel type il peut être comparé. (Généralement, c'est le type de l'objet lui-même, mais il peut aussi être une classe parentale.)
interface publique comparable {public booléen compareto (t autre); }
Par conséquent, l'interface comparable contient un paramètre de type T, qui est le type d'un objet avec lequel une classe qui implémente comparable peut comparer. Cela signifie que si vous définissez une classe qui implémente comparable, comme String, vous devez déclarer non seulement la classe prend en charge la comparaison, mais aussi ce qu'elle peut comparer (généralement à elle-même):
La chaîne de classe publique implémente comparable {...}
Considérons maintenant la mise en œuvre d'une méthode binaire max (). Vous souhaitez accepter deux paramètres du même type, les deux sont comparables et sont comparables les uns aux autres. Heureusement, cela est assez intuitif si vous utilisez des méthodes génériques et des paramètres de type restreint:
public static> t max (t t1, t t2) {if (t1.compareto (t2)> 0) return t1; else return t2; }
Dans cet exemple, vous définissez une méthode générique générée sur le type T, et vous limitez l'extension de type (implémentation) comparable. Les deux paramètres doivent être de type T, ce qui signifie qu'ils sont du même type, de la comparaison de support et sont comparables les uns aux autres. facile!
Encore mieux, le compilateur utilisera le raisonnement de type pour déterminer ce que la valeur de T signifie lorsque max () est appelé. Il n'est donc pas nécessaire de spécifier T, l'appel suivant fonctionnera:
String s = max ("MOO", "Bark");Le compilateur calculera que la valeur prédéterminée de t est la chaîne, donc elle effectuera une compilation et une vérification de type. Mais si vous essayez d'appeler Max () avec des arguments à la classe X qui n'implémente pas comparable, le compilateur ne le permettra pas.
Comparateur
Le comparateur est l'interface du comparateur.
Si nous devons contrôler l'ordre d'une certaine classe, qui ne prend pas en charge le tri (c'est-à-dire qu'il n'implémente pas l'interface comparable); Ensuite, nous pouvons établir un "comparateur de cette classe" à trier. Ce "comparateur" n'a qu'à implémenter l'interface du comparateur.
Autrement dit, nous pouvons créer un nouveau comparateur en "implémentant la classe de comparaison", puis trier la classe via le comparateur.
L'interface du comparateur ne comprend que deux fonctions, et sa définition est la suivante:
package java.util; comparateur d'interface publique <T> {int compare (t o1, t o2); booléen égaux (objet obj);} illustrer:
1. Si une classe souhaite implémenter l'interface du comparateur: elle doit implémenter la fonction compareto (t o1, t o2), mais elle peut ne pas implémenter la fonction égale (objet obj).
Pourquoi ne pouvons-nous pas implémenter la fonction Equals (Object OBJ)? Parce que par défaut, égal (objet obj) a été implémenté. Toutes les classes de Java sont héritées de java.lang.object, et la fonction equals (objet obj) est implémentée dans object.java; Par conséquent, toutes les autres classes équivalent à la mise en œuvre de cette fonction.
2. en comparer (t o1, t o2) est "Comparez les tailles d'O1 et O2". Le retour du «nombre négatif» signifie que «O1 est inférieur à O2»; Retour "zéro", ce qui signifie "O1 est égal à O2"; Le retour du "nombre positif" signifie "O1 est supérieur à O2".
Comparateur et comparable
Comparable est une interface de tri; Si une classe implémente une interface comparable, cela signifie "cette classe prend en charge le tri".
Le comparateur est un comparateur; Si nous devons contrôler l'ordre d'une certaine classe, nous pouvons établir un "comparateur de cette classe" pour le trier.
Il n'est pas difficile de constater que comparable équivaut à un "comparateur interne", tandis que le comparateur est équivalent à un "comparateur externe".
Nous utilisons un programme de test pour illustrer ces deux interfaces. Le code source est le suivant:
Importer java.util. *; Importer java.lang.comparable; / ** * @desc comparaison du programme entre "Comparator" et "Comparable". * (01) "Comparable" * Il s'agit d'une interface de tri qui ne contient qu'une seule fonction compareto (). * Une classe implémente l'interface comparable, qui signifie "la classe elle-même prend en charge le tri", qui peut être trié directement via des arrays.sort () ou des collections.sort (). * (02) "Comparateur" * Il s'agit d'une interface de comparaison, y compris deux fonctions: compare () et equals (). * Une classe implémente l'interface du comparateur, alors c'est un "comparateur". D'autres classes peuvent être triées en fonction du comparateur. * * Pour résumer: comparable est un comparateur interne, tandis que le comparateur est un comparateur externe. * Une classe elle-même implémente un comparateur comparable, ce qui signifie qu'il prend en charge le tri; S'il n'implémente pas lui-même, il peut également être trié via le comparateur du comparateur externe. * / classe publique CompareCompparatorAndComparableTest {public static void main (String [] args) {// Créer un nouveau ArrayList (Dynamic Array) ArrayList <ponv> list = new ArrayList <onon> (); // Ajouter un objet à ArrayList list.add (New Person ("CCC", 20)); list.add (new personne ("AAA", 30)); list.add (new personne ("BBB", 10)); list.add (new personne ("DDD", 40)); // Imprime la séquence d'origine de la liste System.out.printf ("Sort original, liste:% s / n", liste); // trier la liste // ici, il sera trié en fonction de l'interface «String> comparable implémentée par personne», c'est-à-dire triée en fonction du «nom», Collection.Sort (liste); System.out.printf ("Name Sort, List:% S / N", List); // Trier la liste via "Comparator (ascageCaparator)" // La méthode de tri d'AscageCaparator est: triée en fonction de l'ordre ascendant de "Age" Collection.Sort (List, New AscageCaparator ()); System.out.printf ("ASC (Age) Sort, liste:% S / N", liste); // Trier la liste via "Comparator (DescageCompparator)". // La méthode de tri de DescageCaparator est: Trier en fonction de l'ordre décroissant des collections "Age ".Sort (List, New DescageCaparator ()); System.out.printf ("DESC (Age) Sort, liste:% S / N", liste); // déterminer si les deux personnes sont des testiques égaux (); } / ** * @desc tester si les deux personnes sont égales. * Puisque la personne implémente la fonction Equal (): si l'âge et le nom des deux personnes sont égaux, les deux personnes sont considérées comme égales. * Ainsi, ici P1 et P2 sont égaux. * * TODO: si la fonction equals () en personne est supprimée, alors p1 n'équivaut pas p2 * / private static void testequals () {personne p1 = new personne ("eee", 100); Personne P2 = nouvelle personne ("EEE", 100); if (p1.equals (p2)) {System.out.printf ("% s égal% s / n", p1, p2); } else {System.out.printf ("% s pas égal% s / n", p1, p2); }} / ** * Classe de personne @descs. * La personne met en œuvre l'interface comparable, ce qui signifie que la personne elle-même prend en charge le tri * / la classe statique privée, la personne met en œuvre <ony> {int Age; Nom de chaîne; Personne publique (nom de chaîne, int age) {this.name = name; this.age = âge; } public String getName () {Nom de retour; } public int getage () {return âge; } public String toString () {Nom de retour + "-" + âge; } / ** * Comparez si deux personnes sont égales: si leur nom et leur âge sont égaux, ils sont considérés comme égaux * / booléens égaux (personne personne) {if (this.age == personne.age && this.name == personne.name) return true; retourne false; } / ** * @desc Implémentez l'interface de "Comparable <string>", c'est-à-dire réécrivez la fonction compareto <t t>. * Voici une comparaison du "nom de la personne" * / @Override public int compareto (personne personne) {return name.compareto (personne.name); // Renvoie ce.name - Person.name; }} / ** * @Desc AscageCompparator Comparator * Il s'agit de "comparateur ascendant de l'âge de la personne" * / classe statique privée AscageCompparator implémente le comparateur <ony> {@Override public int compare (personne p1, personne p2) {return p1.getage () - p2.Getage (); }} / ** * @desc descageCompparator Comparator * Il s'agit de "comparateur ascendant de l'âge de la personne" * / classe statique privée DescageCompparator implémente le comparateur <onvère> {@Override public int compare (personne p1, personne p2) {return p2.Getage () - P1.Getage (); }}} Ce qui suit est une explication de ce programme.
1. Définition de la classe des personnes. comme suit:
La classe de classe statique privée met en œuvre un <ony> {int à l'âge; Nom de chaîne; ... / ** * @desc implémente l'interface de "Comparable <string>", c'est-à-dire, remplacez la fonction compareto <t t>. * Voici une comparaison du "nom de la personne" * / @Override public int compareto (personne personne) {return name.compareto (personne.name); // Renvoie ce.name - Person.name; }} illustrer:
(1) La classe de personne représente une personne. Il y a deux attributs dans la classe Persong: l'âge (âge) et le nom de "nom de la personne".
(2) La classe de personne implémente l'interface comparable, donc elle peut être triée.
2. Dans main (), nous créons le tableau de liste de la personne (liste). comme suit:
// Créer un nouvel arrayList (Dynamic Array) ArrayList <ponse> list = new ArrayList <onon> (); // Ajouter un objet à ArrayList list.add (new Person ("CCC", 20)); list.add (new personne ("aaa", 30)); list.add (new personne ("bbb", 10)); list.addd (new personne ("ddd", 40); 3. Ensuite, nous imprimons tous les éléments de la liste. comme suit:
// Imprime la séquence d'origine de la liste System.out.printf ("Sort original, liste:% s / n", liste); 4. Ensuite, nous trierons la liste via la fonction SORT () des collections.
Étant donné que la personne implémente l'interface comparable, lors du tri via Sort (), elle sera triée en fonction de la méthode de tri soutenue par la personne, c'est-à-dire les règles définies par Compareto (personne personne). comme suit:
// trier la liste // ici, nous allons trier en fonction de l'interface «string> comparable implémentée par personne», c'est-à-dire en triant selon les collections "name ".sort (liste); System.out.printf ("Name Sort, List:% S / N", List); 5. Comparable et comparateur
Nous définissons deux comparateurs, AscageCaparator et DescageCaparator, pour monter et inférieur à la personne de l'ordre respectivement.
6.AscageCaparator Comparator Il trie la personne dans l'ordre croissant par âge. Le code est le suivant:
/ ** * @desc AscageCaparator Comparator * Il s'agit de "comparateur ascendant de l'âge de la personne" * / classe statique privée AscageCaparator implémente le comparateur <honomètre> {@Override public int compare (personne p1, personne p2) {return p1.getage () - p2.getage (); }} 7. Descagecomparator Comparator Il trie la personne en ordre décroissant par âge. Le code est le suivant:
/ ** * @desc descageCaparator Comparator * Il s'agit de "comparateur ascendant de l'âge de la personne" * / classe statique privée DescageCaparator implémente le comparateur <ony> {@Override public int compare (personne p1, personne p2) {return p2.Getage () - p1.getage (); }} 8. Exécutez le programme en conséquence, la sortie est la suivante:
Sort original, liste: [CCC - 20, AAA - 30, BBB - 10, DDD - 40] Nom Sort, liste: [AAA - 30, BBB - 10, CCC - 20, DDD - 40] ASC (Age) Sort, Liste: [BBB - 10, CCC - 20, AAA - 30, DDD - 40] DESC (AGE) SORT, LISTE: [DDD - 40, AAA - 30, CCC-20) bbb - 10] eee - 100 eee égal - 100