Vergleichbar
Vergleichbar ist die Sortierschnittstelle.
Wenn eine Klasse die vergleichbare Schnittstelle implementiert, bedeutet dies, dass "diese Klasse unterstützt". Da Klassen, die eine vergleichbare Schnittstellen -Unterstützung implementieren, die Sortierung des Sortierens unter der Annahme, dass es jetzt eine "Listenliste (oder ein Array) von Objekten von Klassen gibt, die eine vergleichbare Schnittstelle implementieren", können die Liste (oder ein Array) nach Collections.sort (oder Arrays.Sort) sortiert werden.
Zusätzlich kann "Objekt der Klasse, das eine vergleichbare Schnittstelle implementiert", als Schlüssel in einer "geordneten Karte (wie Treemap)" oder als Element in einem "geordneten Satz (Treeset)" verwendet werden, ohne einen Komparator anzugeben.
Die vergleichbare Schnittstelle enthält nur eine Funktion, und ihre Definition lautet wie folgt:
Paket Java.lang; Import Java.util.
Beschreibung: Angenommen, wir "vergleichen die Größen von x und y" über X.comPareto (y). Wenn Sie eine "negative Zahl" zurückgeben, bedeutet dies "X ist kleiner als y"; Wenn Sie eine "Null" zurückgeben, bedeutet es "X ist gleich Y"; Wenn Sie eine "positive Zahl" zurückgeben, bedeutet dies "X ist größer als y".
Die vergleichbare Schnittstelle war generisch, so dass das Objekt, das vergleichbar implementiert, erklärt, mit welchem Typ es verglichen werden kann. (Im Allgemeinen ist dies der Typ des Objekts selbst, aber es kann manchmal auch eine übergeordnete Klasse sein.)
öffentliche Schnittstelle vergleichbar {public boolean vergleicheto (t Andere); }
Daher enthält die vergleichbare Schnittstelle einen Typparameter t, der die Art eines Objekts ist, mit dem eine Klasse vergleichbar impliziert wird. Dies bedeutet, dass Sie, wenn Sie eine Klasse definieren, die vergleichbar implementiert, wie z. B. String, nicht nur die Klasse für den Vergleich deklarieren muss, sondern auch, mit dem sie vergleichen kann (normalerweise mit sich selbst):
öffentliche Klasse -Zeichenfolge implementiert vergleichbar {...}
Betrachten wir nun die Implementierung einer binären Max () -Methode. Sie möchten zwei Parameter desselben Typs akzeptieren, beide sind vergleichbar und vergleichbar miteinander. Glücklicherweise ist dies ziemlich intuitiv, wenn Sie generische Methoden und eingeschränkte Typparameter verwenden:
public static> t max (t t1, t t2) {if (t1.comPareto (t2)> 0) return t1; sonst zurück T2 zurückgeben; }
In diesem Beispiel definieren Sie eine generische Methode, die auf Typ T generiert wird, und beschränken die Type -Erweiterung (Implementierung) vergleichbar. Beide Parameter müssen vom Typ t sein, was bedeutet, dass sie denselben Typ haben, den Vergleich unterstützen und miteinander vergleichbar sind. einfach!
Noch besser ist, dass der Compiler das Typ -Argument verwendet, um festzustellen, was der Wert von T bedeutet, wenn max () aufgerufen wird. Es müssen also überhaupt nicht angegeben werden. Der folgende Anruf funktioniert:
String S = max ("moo", "bark");Der Compiler berechnet, dass der vorgegebene Wert von T die Zeichenfolge ist, sodass die Kompilierung und die Typüberprüfung durchgeführt werden. Wenn Sie jedoch versuchen, Max () mit Argumenten an Klasse X anzurufen, die nicht vergleichbar implementiert werden, erlaubt der Compiler dies nicht.
Vergleicher
Der Komparator ist die Komparatorschnittstelle.
Wenn wir die Reihenfolge einer bestimmten Klasse steuern müssen, die selbst nicht die Sortierung unterstützt (dh die vergleichbare Schnittstelle implementiert); Dann können wir einen "Komparator dieser Klasse" einrichten, um sie zu sortieren. Dieser "Komparator" muss nur die Komparatorschnittstelle implementieren.
Das heißt, wir können einen neuen Komparator erstellen, indem wir "die Komparatorklasse implementieren" und dann die Klasse durch den Komparator sortieren.
Die Komparatorschnittstelle enthält nur zwei Funktionen, und ihre Definition lautet wie folgt:
Paket java.util; public interface vergleicher <t> {int compare (t o1, t o2); booleschen gleich (Objekt OBJ);} veranschaulichen:
1. Wenn eine Klasse die Komplexschnittstelle implementieren möchte: Sie muss die Funktion vergleicheto (T O1, T O2) implementieren, die Funktion der Equals (Object OBJ) jedoch möglicherweise nicht implementiert.
Warum können wir die Funktion Equals (Object OBJ) nicht implementieren? Weil standardmäßig Equals (Object OBJ) implementiert wurde. Alle Klassen in Java werden von java.lang.object geerbt, und die Equals (Object OBJ) -Funktion wird in Object.java implementiert. Daher entsprechen alle anderen Klassen der Implementierung dieser Funktion.
2.Int vergleiche (T O1, T O2) ist "Vergleiche die Größen von O1 und O2". Rückgabe "negativer Zahl" bedeutet "O1 ist kleiner als O2"; Rückgabe "Null", was "O1 ist gleich O2"; Rückgabe "positive Zahl" bedeutet "O1 ist größer als O2".
Vergleicher und vergleichbar
Vergleichbar ist eine Sortierschnittstelle; Wenn eine Klasse eine vergleichbare Schnittstelle implementiert, bedeutet dies, dass "diese Klasse unterstützt".
Vergleicher ist ein Vergleicher; Wenn wir die Reihenfolge einer bestimmten Klasse kontrollieren müssen, können wir einen "Komparator dieser Klasse" festlegen, um sie zu sortieren.
Es ist nicht schwer zu finden, dass vergleichbar einem "internen Vergleicher" entspricht, während der Komparator einem "externen Komparator" entspricht.
Wir verwenden ein Testprogramm, um diese beiden Schnittstellen zu veranschaulichen. Der Quellcode lautet wie folgt:
Java.util importieren. * (01) "vergleichbar" * Es ist eine Sortierschnittstelle, die nur eine Funktion vergleiche () enthält. * Eine Klasse implementiert die vergleichbare Schnittstelle, was bedeutet, dass "die Klasse selbst unterstützt Sortierung", die direkt über Arrays.sort () oder collections.sort () sortiert werden kann. * (02) "Comparator" * Es handelt sich um eine Komparator -Schnittstelle, einschließlich zwei Funktionen: Compare () und Equals (). * Eine Klasse implementiert die Komparatorschnittstelle, dann ist sie ein "Komparator". Andere Klassen können nach dem Komparator sortiert werden. * * Zusammenfassend: Vergleichbar ist ein interner Komparator, während der Komparator ein externer Komparator ist. * Eine Klasse selbst implementiert einen vergleichbaren Komparator, was bedeutet, dass sie die Sortierung unterstützt; Wenn es nicht vergleichbar selbst implementiert, kann es auch durch den externen Komparator -Komparator sortiert werden. */public class vergleichEcomparatorandComparabletest {public static void main (string [] args) {// Erstellen Sie eine neue ArrayList (Dynamic Array) ArrayList <Person> list = new ArrayList <Person> (); // Fügen Sie ein Objekt zur ArrayList -Liste hinzu.Add (neue Person ("CCC", 20)); list.add (neue Person ("AAA", 30)); list.add (neue Person ("BBB", 10)); list.add (neue Person ("ddd", 40)); // Drucken Sie die Originalsequenz des List -Systems.out.printf ("Original Sortierung, Liste:%s/n", Liste); // Sortieren Sie die Liste // Hier wird sie nach der "Vergleichbaren <String> -Rittel, die von der Person implementiert" sortiert wird, dh nach "Name", Collections.sort (Liste), sortiert. System.out.printf ("Name sortieren, Liste:%s/n", Liste); // Sortieren Sie die Liste über "Comparator (AscageComparator)" // Die Sortiermethode von AscageComparator ist: sortiert nach der Aufstiegsreihenfolge von "Altersersammlungen" (Liste, neuer AscageComparator ()); System.out.printf ("ASC (Alter) Sortierung, Liste:%S/N", Liste); // Sortieren Sie die Liste durch "Comparator (DescageComparator)". // Die Sortiermethode des DescageComparators lautet: Sortieren nach der absteigenden Reihenfolge der "Alterszeit" -Sammeln (Liste, neuer DescageComparator ()); System.out.printf ("Desc (Alter) Sortierung, Liste:%S/N", Liste); // bestimmen, ob die beiden Personen gleiche Testequals sind (); } /*** @desc testen Sie, ob die beiden Personen gleich sind. * Da Person die Equals () -Funktion implementiert: Wenn Alter und Name der beiden Personen gleich sind, gelten die beiden Personen als gleich. * Also, hier sind P1 und P2 gleich. * * Todo: Wenn die Equals () -Funktion persönlich entfernt wird, dann entspricht P1 nicht p2 */ privat statische void Testequals () {Person p1 = neue Person ("eee", 100); Person p2 = neue Person ("eee", 100); if (p1.equals (p2)) {System.out.printf (" %s Equal %S/N", p1, p2); } else {System.out.printf (" %s nicht gleich %S/N", p1, p2); }} /*** @Desc Person Class. * Person implementiert die vergleichbare Schnittstelle, was bedeutet, dass die Person selbst Sortierung unterstützt*/ private statische Klasse implementiert vergleichbare <person> {int Age; Zeichenfolge Name; public person (String name, int age) {this.name = name; this.age = Alter; } public String getName () {return name; } public int getage () {return ay; } public String toString () {return name + " -" + älter; } / *** Vergleichen Sie, ob zwei Personen gleich sind: Wenn ihr Name und ihr Alter gleich sind, gelten sie als gleich* / boolean gleich (Person Person) {if (this.age == Person.age && this.name == Person.name) return true; false zurückgeben; } /*** @desc implementieren Sie die Schnittstelle von "vergleichbar <string>", dh die Vergleiche <T T> -Funktion. * Hier ist ein Vergleich mit "Personname"*/ @Override public int vergleicheto (Person Person) {return name.comPareto (Person.Name); // this.name - person.name; }} / *** @desc ascageComparator Complexator* Es ist "Ascending Comparator of Person's Age"* / private statische Klasse AscageComparator implementiert Comparator <Person> {@Override public int Compare (Person p1, Person p2) {return p1.getage () - p2.getage (); }} / *** @desc descageComparator Vergleicher* Es ist "Aufstieg vergleicher des Alters der Person"* / private statische Klasse DescageComparator implementiert CompueS <Person> {@Override public int Compare (Person P1, Person p2) {return p2.getage () - p1.getage (); }}} Das Folgende ist eine Erklärung dieses Programms.
1. persönliche Klassendefinition. wie folgt:
private statische Klassen Person implementiert vergleichbar <person> {int age; Zeichenfolge Name; ... /*** @desc implementiert die Schnittstelle von "vergleichbar <string>", dh die Vergleiche <T T> -Funktion. * Hier ist ein Vergleich mit "Personname"*/ @Override public int vergleicheto (Person Person) {return name.comPareto (Person.Name); // this.name - person.name; }} veranschaulichen:
(1) Die Personklasse repräsentiert eine Person. Es gibt zwei Attribute in der Persong -Klasse: Alter (Alter) und Name "Personenname".
(2) Die Personklasse implementiert die vergleichbare Schnittstelle, sodass sie sortiert werden kann.
2. In main () erstellen wir das Listenarray (Liste) der Person. wie folgt:
// Erstellen Sie eine neue ArrayList (Dynamic Array) ArrayList <Person> list = new ArrayList <Person> (); // Fügen Sie ein Objekt zur listlist -Liste hinzu.
3. Als nächstes drucken wir alle Elemente der Liste aus. wie folgt:
// Drucken Sie die Originalsequenz von List System.out.printf ("Original -Sortierung, Liste:%s/n", Liste); 4. Dann sortieren wir die Liste über die Sort () -Funktion von Sammlungen.
Da die Person die vergleichbare Schnittstelle implementiert, wird sie bei Sortieren von Sort () nach der von Person unterstützten Sort -Methode sortiert, dh den von Vergleiche (Person) definierten Regeln (Person). wie folgt:
// Sortieren Sie die Liste // Hier sortieren wir nach der von Person implementierten "Vergleichbaren <String> -Zusschnitteln", dh nach "Name" collectionss.sort (Liste); System.out.printf ("Name sortieren, Liste:%s/n", Liste); 5. Vergleichbar und Vergleicher
Wir definieren zwei Komparatoren, Ascagecomparator und DescageComparator, um eine Person aufzusteigen und zu senken.
6.AscageComparator -Komparator Es sortiert Person in aufsteigender Reihenfolge nach Alter. Der Code ist wie folgt:
/*** @Desc ascageComparator Complexator* Es ist "Ascending Comparator of Person's Age"*/private statische Klasse AscageComparator implementiert Comparator <Person> {@Override public int compare (Person p1, Person p2) {return p1.getage () - p2.getage (); }} 7.DescageComparator -Komparator Es sortiert die Person in absteigender Reihenfolge nach Alter. Der Code ist wie folgt:
/*** @desc descageComparator Comparator* Es ist "Aufstieg vergleicher des Alters der Person"*/private statische Klasse DescageComparator implementiert Comparator <Person> {@Override public int compare (Person p1, Person p2) {return p2.getage () - p1.getage (); }} 8. Führen Sie das Programm als Ergebnis aus, die Ausgabe lautet wie folgt:
Original -Sortierung, Liste: [CCC - 20, AAA - 30, BBB - 10, DDD - 40] Name Sortierung, Liste: [AAA - 30, BBB - 10, CCC - 20, DDD - 40] ASC (Alter) Sortierung: [BBB - 10, CCC - 20, AAA - 30, DDD - 40] Desc (AGE (AGE). BBB - 10] EEE - 100 Equal Eee - 100