Test 1:
Schauen wir uns zunächst einen Satz von Vergleiche vom String -Typ an. Geben Sie ohne weiteres den Code ein:
public class test {public static void main (String [] args) {String a = "Java Book Garden"; String B = "Java Book Garden"; String c = neuer String ("Java -Buchgarten"); String d = new String ("Java Book Garden"). Praktikum (); if (a == b) {System.out.println ("a == b"); } else {System.out.println ("a! = b"); } if (a.equals (b)) {System.out.println ("A.equals (b)"); } else {System.out.println ("! A.equals (b)"); } if (a == c) {System.out.println ("a == c"); } else {System.out.println ("a! = c"); } if (a.equals (c)) {System.out.println ("A.equals (c)"); } else {System.out.println ("! A.equals (c)"); } if (a == d) {System.out.println ("a == d"); } else {System.out.println ("a! = d"); } if (a.equals (d)) {System.out.println ("A.equals (d)"); } else {System.out.println ("A.Equals (d)"); }}}Ausgangsergebnis:
a == ba.equals (b) a! = ca.equals (c) a == da.equals (d)
Zusammenfassen:
Ergebnis A == B: Wenn das Programm ausgeführt wird, wird ein String -Pufferpool erstellt. Wenn String a = "Java Book Garden", "Java Book Garden" wird im Saitenpufferpool platziert. Wenn String B = "Java Book Garden" eine Zeichenfolge erstellt, sucht das Programm zunächst nach Objekten mit dem gleichen Wert in diesem String -Pufferpool. Wenn b erstellt wird, findet das Programm A mit demselben Wert und verweist auf das von A verwiesene Objekt. Daher beziehen sich A und B auf dasselbe Objekt, also a == b.
Infolgedessen ist ein! Also a! = C.
Ergebnis A == D: Wenn die Praktikantenmethode aufgerufen wird, wenn der Pool bereits eine Zeichenfolge enthält, die diesem String -Objekt entspricht (das Objekt wird durch die Equals (Object) -Methode), wird die Zeichenfolge im Pool zurückgegeben. Fügen Sie dieses String -Objekt ansonsten dem Pool hinzu und geben Sie eine Referenz auf dieses String -Objekt zurück. Alle d rufen Objekte von a an.
Equals vergleicht die Werte. Wenn die Werte gleich sind, sind sie gleich.
Test 2:
Hier ist ein Test einer Reihe von INT -Typen und Ganzzahltypen:
public class test {public static void main (String [] args) {int a = 127; int a1 = 127; int b = 128; Ganzzahl c = 127; Ganzzahl C1 = 127; Ganzzahl d = 128; Ganzzahl D1 = 128; if (a == a1) {System.out.println ("a == a1"); } else {System.out.println ("a! = a1"); } if (b == b1) {System.out.println ("B == B1"); } else {system.out.println ("b! = b1"); } if (c == c1) {System.out.println ("c == c1"); } else {System.out.println ("c! = c1"); } if (d == d1) {System.out.println ("d == d1"); } else {System.out.println ("D! = D1"); }}}Ausgangsergebnis:
a == a1b == B1C == C1D! = D1
Das Ergebnis "a == a1" und "b == b1": int sind grundlegende Typen, und die Werte werden direkt gespeichert, während Ganzzahl ein Objekt ist und mit einer Referenz auf dieses Objekt zeigt. Die meisten Vergleiche bestehen aus "a == a1" und "b == b1".
Die Ergebnisse "C == C1" und "D! = D1" können hier Fragen haben, warum "D! = D1". Schauen wir uns den Quellcode der Ganzzahl zusammen an.
/** * Cache zur Unterstützung der Objektidentitätssemantik des Autoboxens für Werte zwischen * -128 und 127 (inklusive), wie von JLS gefordert. * * Der Cache wird bei der ersten Verwendung initialisiert. Die Größe des Cache * kann durch die Option -xx: autoboxcachemax = <größe> gesteuert werden. * Während der VM -Initialisierung kann Java.lang.Ineger.Inegercache.High Property * in den privaten Systemeigenschaften in der Klasse * sun.misc.vm gespeichert werden. */ private statische Klasse IntegerCache {statische endgültige int low = -128; statische endgültige int hoch; statischer endgültiger Ganzzahl -Cache []; static {// hoher Wert kann durch Eigenschaft int H = 127 konfiguriert werden; String IntegerCacheHighPropValue = sun.misc.vm.getSavedProperty ("java.lang.Ineger.Inegercache.high"); if (IntegerCacheHighPropValue! i = math.max (i, 127); // Maximale Arraygröße ist integer.max_value h = math.min (i, ginneger.max_value -(-low) -1); } High = H; Cache = New Integer [(hoch - niedrig) + 1]; int j = niedrig; für (int k = 0; k <cache.length; k ++) cache [k] = new Integer (j ++); } private IntegerCache () {}} /** * Gibt eine {@code Integer} -Instanz zurück, die den angegebenen * {@code int} -Wertzust darstellt. Wenn eine neue {@Code Integer} -Instanz nicht erforderlich ist, sollte diese Methode im Allgemeinen für * den Konstruktor {@link #Integer (int)} verwendet werden, da diese Methode wahrscheinlich * ist, um eine signifikant bessere Speicher- und Zeitleistung zu erzielen, indem man häufig gefragte Werte zwischen den Werten versorgt. * * Diese Methode wird immer Werte im Bereich von -128 bis 127, * inklusive und möglicherweise andere Werte außerhalb dieses Bereichs zwischenspeichern. * * @param i an {@code int} Wert. * @return eine {@Code Integer} Instanz, die {@code i} darstellt. * @Since 1.5 */ public static Integer ValueOf (int i) {Assert IntegerCache.High> = 127; if (i> = integercache.low && i <= integercache.high) return IntegerCache.cache [i + (-intergercache.low)]; Neue Ganzzahl zurückgeben (i); }Schlussfolgerung: Hier initialisieren die Ganzzahl einen konstanten Pool von [-128,127]. Wenn sich der Wert in diesem Bereich befindet, wird auf das gleiche Objekt verwiesen. Wenn es nicht in diesem Bereich liegt, ist es aus dem Quellcode ersichtlich, dass das zurückgegebene neue Objekt: Neue Ganzzahl zurückgeben (i);
Daher bezieht sich das Ergebnis "C == C1" auf dasselbe Objekt, und das Ergebnis "D! = D1" bezieht sich auf ein neues neues Objekt, es ist also anders.