Vergleichende Probleme in Java sind sehr grundlegend und leicht zu verwirren. Heute werde ich eine detailliertere Zusammenfassung und Anordnung einiger fehleranfälliger Punkte zusammenfassen und organisieren, in der Hoffnung, dass dies für das Studium und das Interview aller hilfreich sein wird.
1. Die Differenz zwischen == und Equals ()
Zunächst müssen wir den Unterschied zwischen == und Equals () kennen. Das == Zeichen wird immer mit dem Adresswert verglichen. Für grundlegende Datentypen ist der Vergleich tatsächlich, ob die Variablenwerte gleich sind, während der Adresswert für Referenzdatentypen verglichen wird. Was Sie benötigen, um hier besondere Aufmerksamkeit zu schenken, ist der String -Typ, der leicht als selbstverständlich angesehen werden kann und leicht Fehler zu machen ist. Die Equals () -Methode ist eine Methode in der Objektklasse. Wir wissen, dass alle Klassen in Java die Objektklasse standardmäßig erben, sodass die Klassenobjekte die Equals () -Methode haben. Die Equals () -Methode in der Objektklasse ist in der folgenden Abbildung dargestellt:
Wie aus dem Quellcode ersichtlich ist, verwendet die zugrunde liegende Ebene der Equals () -Methode in der Objektklasse auch ==, so dass es tatsächlich der Adresswert ist. Wenn wir also die Equals () -Methode für andere Vergleiche verwenden möchten, müssen wir die Equals () -Methode überschreiben.
2. Grundlegende Datentypen und Verpackungstypen
Wir alle wissen, dass Byte, Short, Int, Long, Boolean, Char, Double und Float grundlegende Datentypen sind, und die von ihnen deklarierten Variablen werden im Stapelspeicher gespeichert. Die durch ihre entsprechenden Verpackungstypen definierten Variablen (Byte, kurz, ganzzahlig, lang, boolean, charakter, doppelt) im Heap -Speicher existieren. Für grundlegende Datentypen ist ihr Vergleich relativ einfach, dh verwendet, um zu bestimmen, ob sie gleich sind, und verwenden <,>, <=,> =, um Größen zu vergleichen. Bei Verpackungstypen ist es jedoch etwas anders.
Erstens, um festzustellen, ob es gleich ist, siehe das Ausführungsergebnis des folgenden Code:
Paket DailyTest; import org.junit.test;/*** Vergleichszusammenfassung in java* @author yrr*/public class Javacomparetest {/*** Integer -Typ ist gleich*/@test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n8); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n1.intValue () == n2.IntValue ()); N6); NullpointException}/*** Langes Typ -Typ ist gleich*/@test public void test02 () {// Beachten Sie hier, dass L oder L bei Verwendung langer Definition nicht erforderlich ist, aber wenn lange verwendet wird, wird ein Fehler angegeben // Fügen Sie es in der Konstruktion hinzu, um die Differenz Long N3 = 48L anzuzeigen. System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n1); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n4 == n5); // Bei Verwendung der Methode Long.intValue () müssen Sie darauf achten, zu überprüfen, ob es sich um NullpointException handelt}}Für die obigen Ausführungsergebnisse wird die folgende Erklärung abgegeben:
Zunächst deklarieren wir für die neue Methode ein Ganzzahl oder ein langes Objekt. Da das neue Objekt ein Stück Platz im Haufen öffnet, auch wenn die Werte der beiden gleich sind, für ==, wird der Adresswert verglichen, sodass falsch zurückgegeben wird. Für die Wrapper -Klassen grundlegender Datentypen wurde die Equals () -Methode umgeschrieben, und die numerische Größe wird verglichen, sodass die Methode Equals () verwendet werden kann, um anhand der numerischen Größe zu beurteilen. In Bezug auf das Problem des Vergleichs von Ganzzahlvariablen mit int -Variablen werden wir feststellen, dass der Vergleichswert auch auf der numerischen Größe basiert. Dies liegt daran, dass der Ganzzahltyp beim Vergleich automatisch nicht enttäuscht und in den INT -Typ konvertiert wird. Die Erklärung der ersten drei Punkte gilt für alle Verpackungsarten. Für die direkte Zuordnungsmethode werden die beiden Ganzzahlvariablen mit einem Wert von 48 durch das == Zeichen als wahr beurteilt, aber wenn der Wert 128 ist, ist er falsch. Dies liegt daran, dass am Ende für Ganzzahl n1 = 48;, die Methode der direkten Zuweisung tatsächlich die Integer.Value () -Methode aufruft. Wir können einen kurzen Blick auf den Quellcode der Integer.Value () -Methode werfen, wie in der folgenden Abbildung gezeigt:
Wir können sehen, dass es hier ein If -Urteil gibt. Wenn der Eingang I im Bereich von [-128, 127] liegt, wird er direkt vom IntegerCache-Array zurückgegeben. Daher werden für Werte in diesem Bereich die Adresswerte, die diesem Array entsprechen, zurückgegeben, sodass die Verwendung des == -Zeichens zu Richter True zurückgegeben wird. Was nicht in diesem Bereich liegt, ist das neu neue Objekt, also wird falsch zurückgegeben. Diese Schlussfolgerung gilt für Byte-, Kurz-, Ganzzahl- und lange Typen (wenn Sie interessiert sind, können Sie den Quellcode ihrer entsprechenden Value () -Methode überprüfen), da der Umfang des Byte-Typs [-128, 127] beträgt.
Für den Größenvergleich gibt es kein Problem mit>, <, <=,> =, und sie werden automatisch nicht geplant. Wir empfehlen jedoch normalerweise, die folgenden zwei Möglichkeiten zum Vergleich von Größen zu verwenden:
Rufen Sie die xxxValue () -Methode auf, um sie zum Vergleich in den grundlegenden Datentyp umzuwandeln. In der Wrapper -Klasse wird die Vergleiche () -Methode umgeschrieben. Durch Betrachtung des Vergleichs -Quellcodes können Sie feststellen, dass die zugrunde liegende Verwendung tatsächlich auch in den entsprechenden Basistetyp konvertiert wird, indem er automatisch entbotzt und anschließend verglichen wird.
2. Vergleich von Java -Objekten
Mit der obigen Einführung ist es einfacher, Objekte zu vergleichen. Die Prinzipien sind gleich.
1. Vergleich der Streichentypen
Es ist zu beachten, dass der String -Typ nicht direkt>, <=,> = und <verwendet werden kann und eine Kompilierungsausnahme meldet.
Paket DailyTest; import org.junit.test;/*** Vergleichszusammenfassung in java* @author yrr*/public class Javacomparetest {@Test public void test03 () {String s1 = new String ("123"); String S2 = New String ("123"); System.out.println (S1 == S2); // False System.out.println (S1.Equals (S2)); String S3 = "234"; String S4 = "234"; System.out.println (S3 == S4); // True System.out.println (S3.Equals (S4)); // true //system.out.println(s1 <= s3); // Der Operator <ist für die Argumenttyp (en) java.lang.string, java.lang.string system.out.println (S1.comPareto (S3) <0) nicht definiert; //WAHR }}2. Vergleich von Klassenobjekten
Die Schlussfolgerung von Klassenobjekten ist gleich, aber im Vergleich zu grundlegenden Datentypen und String -Typen ist es etwas komplizierter.
Nach einer bestimmten Regel muss die Methode Equals () in der beurteilten Klasse umschreiben, um festzustellen, ob die beiden Objekte gleich sind. Der Beispielcode lautet wie folgt:
Paket DailyTest; import org.junit.test;/*** Vergleichszusammenfassung in java* @author yrr*/public class Javacomparetest {@Test public void test04 () {Person p1 = new Person ("yrr", 18); Person p2 = neue Person ("yrr", 18); System.out.println (p1 == p2); // false system.out.println (p2.equals (p1)); // true}} Klasse Person {privater Zeichenfolge Name; privates Ganzzahlalter; public person () {} public person (String -Name, Ganzzahl Alter) {this.name = name; this.age = Alter; } public String getName () {return name; } public Integer getage () {Return Age; } @Override public boolean gleich (Objekt obj) {Person Person = (Person) obj; return name.equals (person.getName ()) && ay.equals (person.getage ()); }}Und wenn Sie die Größen zweier Objekte vergleichen möchten (dies ist auch eine gemeinsame Interviewfrage), gibt es zwei Möglichkeiten:
Die vergleichbare Klasse implementiert die vergleichbare Schnittstelle und überschreibt die Vergleiche () -Methode, um die Klasse zu definieren, die eine Komparatorschnittstelle implementiert, oder die interne Klasse zum Überschreiben der Compare () -Methode: Ersteres ist in der vergleichbaren Klasse definiert, während die letztere außerhalb der vergleichbaren Klasse definiert ist. Durch diesen Unterschied sind auch die Vor- und Nachteile der beiden offensichtlich. Ersteres ist einfach, erfordert jedoch eine Änderung der verglichenen Klasse, während letztere den ursprünglichen Code nicht ändern muss, was flexibler ist.
Die erste Methode, der Beispielcode, lautet wie folgt:
Paket DailyTest; import org.junit.test;/*** Vergleichszusammenfassung in Java* @author yrr*/public class Javacomparetest {@Test public void test5 () {Person p1 = new Person ("yrr", 18); Person P2 = neue Person ("WX", 19); System.out.println (p1.comPareto (p2) <0); }} Klasse Person implementiert einen vergleichbaren <person> {privaten String -Namen; privates Ganzzahlalter; public person () {} public person (String -Name, Ganzzahl Alter) {this.name = name; this.age = Alter; } public Integer getage () {Return Age; } @Override public int vergleicheto (Person o) {return this.getage () - o.getage (); }}Die zweite Methode, der Beispielcode, lautet wie folgt:
Paketvergleich; import Java.util.Arrays; Import Java.util.comParator; öffentliche Klasse MyComparator {public static void main (String [] args) {user [] user = new user [] {new user ("u1001", 25), neuer Benutzer ("u1002", 20), neuer Benutzer ("u1003", 21)}; Arrays.sort (Benutzer, neuer Komparator <Unters> () {@Override public int compare (Benutzer O1, Benutzer O2) {return o1.getage () - o2.getage ();}}); für (int i = 0; i <user.Length; i ++) {user user = user [i]; System.out.println (user.getId () + "" + user.getage ()); }}} Klasse Benutzer {private String -ID; privates int Alter; public user (string id, int ay) {this.id = id; this.age = Alter; } public int getage () {return ay; } public void setage (int age) {this.age = älter; } public String getId () {return id; } public void setID (String -ID) {this.id = id; }}Das obige ist der relevante Inhalt der Java -Vergleichsfragen, die ich Ihnen diesmal gesagt habe. Wenn Sie andere Fragen haben, können Sie sie im Kommentarbereich unten besprechen. Vielen Dank für Ihre Unterstützung.