-
s = new String("xyz"); Wie viele String-Objekte werden erstellt? Zwei Objekte, eines ist „xyx“ und das andere ist das Referenzobjekt s, das auf „xyx“ zeigt.
String s="Hallo";int i=3; s=i+s; Ist dieser Ausdruck korrekt? Wird angezeigt, dass der Datentyp nicht übereinstimmt. Weil string eine Klasse ist! Richtiger Ansatz: s+="3" oder s+='3' oder s+=(char)i;
Wir werden eine andere Möglichkeit zum Erstellen von String-Objekten vorstellen – in Anführungszeichen eingeschlossenen Text. Diese Methode ist einzigartig für String und unterscheidet sich stark von der neuen Methode.
In der JAVA Virtual Machine (JVM) gibt es einen String-Pool, der viele String-Objekte speichert und gemeinsam genutzt werden kann, wodurch die Effizienz verbessert wird. String a="abc";: Wenn diese Codezeile ausgeführt wird, durchsucht die virtuelle JAVA-Maschine zunächst den String-Pool, um festzustellen, ob ein solches Objekt mit dem Wert „abc“ bereits vorhanden ist. Die Grundlage für die Beurteilung ist String-Klasse gleich(Objekt obj) Der Rückgabewert der Methode. Wenn dies der Fall ist, wird kein neues Objekt erstellt und eine Referenz auf das vorhandene Objekt wird direkt zurückgegeben. Andernfalls wird das Objekt zuerst erstellt, dann dem String-Pool hinzugefügt und dann seine Referenz zurückgegeben.
Erstellung von String-Objekten: Aufgrund der umfangreichen Verwendung von String-Objekten [es handelt sich um ein Objekt, im Allgemeinen belegen Objekte immer Speicher im Heap], um in Java Speicherplatz und Laufzeit zu sparen [z. B. beim Vergleichen von Strings, == ist besser als equal()], alle String-Literale werden während der Kompilierungsphase in einen Literal-Pool gelegt und der Laufzeit-Literal-Pool wird Teil des Konstanten-Pools. Der Vorteil des Literalpools besteht darin, dass alle gleichen Zeichenfolgenkonstanten im Pool zusammengeführt werden und nur einen Platz belegen. Wir wissen, dass für zwei Referenzvariablen == verwendet wird, um zu bestimmen, ob ihre Werte [Referenzen] gleich sind, das heißt, sie zeigen auf dasselbe Objekt:
Schauen Sie sich nun die Anweisung String s = new String("abc"); an. Hier ist „abc“ selbst ein Objekt im Pool, und wenn new String() zur Laufzeit ausgeführt wird, wird eine Kopie des Objekts im Pool platziert im Heap und übergeben Sie die Referenz dieses Objekts im Heap an s. ok, diese Anweisung erstellt 2 String-Objekte.
String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //Anweisung, die nicht ausgeführt wird}
//Wie viele String-Objekte wurden erstellt? [Drei, eines im Pool und zwei im Heap. ]
Dem String-Pool werden nur neue Objekte hinzugefügt, die durch eine „+“-Verbindung zwischen String-Objekten generiert werden, die mit Anführungszeichen erstellt wurden, um Text einzuschließen. Bei allen „+“-Verbindungsausdrücken, die neue Objekte enthalten, die in der neuen Methode erstellt wurden (einschließlich Null), werden die von ihnen generierten neuen Objekte nicht zum Zeichenfolgenpool hinzugefügt.
1.== bedeutet, dass sie von demselben Objekt referenziert werden, und equal() bedeutet, dass die Werte gleich sind.
String str1 = „abc“; das referenzierte Objekt befindet sich auf dem Stapel (oder String-Pool).
String str1 =new String ("abc"); Das referenzierte Objekt befindet sich im Speicher/Heap.
2.String str1 = „string“; im Stapel
String str3 = "str"; auf dem Stapel
String str4 = "ing"; auf dem Stapel
String str2 = str3+str4; im Heap, da die Funktion des +-Zeichens darin besteht, ein weiteres neu erstelltes String-Objekt zurückzugeben, anstatt auf dem Stapel nach dem String-Wert zu suchen. Wenn es String str2 = "str"+"ing" ist, liegt das Endergebnis auf dem Stapel. str1==str2 ist wahr.
Aber es gibt eine Situation, die unsere Aufmerksamkeit erfordert. Bitte schauen Sie sich den folgenden Code an:
öffentliche Klasse StringStaticTest {
public static final String A = „ab“; // Konstante A
public static final String B = „cd“; // Konstante B
public static void main(String[] args) {
String s = A + B; // Initialisiere s, indem du die beiden Konstanten mit + verbindest
String t = "abcd";
if (s == t) {
System.out.println("s ist gleich t, sie sind das gleiche Objekt");
} anders {
System.out.println("s ist nicht gleich t, sie sind nicht dasselbe Objekt");
}
}
}
Das Ergebnis der Ausführung dieses Codes ist wie folgt:
s ist gleich t, sie sind das gleiche Objekt
Der Grund dafür ist, dass im obigen Beispiel A und B Konstanten sind und ihre Werte fest sind, sodass auch der Wert von s fest ist und beim Kompilieren der Klasse bestimmt wurde. Das heißt: String s=A+B; ist äquivalent zu: String s="ab"+"cd";
Lassen Sie mich das obige Beispiel leicht ändern und sehen, was passiert:
öffentliche Klasse StringStaticTest {
öffentlicher statischer finaler String A; // Konstante A
öffentlicher statischer finaler String B; // Konstante B
statisch {
A = „ab“;
B = „cd“;
}
public static void main(String[] args) {
// Initialisiere s, indem du die beiden Konstanten mit + verbindest
Zeichenfolge s = A + B;
String t = "abcd";
if (s == t) {
System.out.println("s ist gleich t, sie sind das gleiche Objekt");
} anders {
System.out.println("s ist nicht gleich t, sie sind nicht dasselbe Objekt");
}
}
}
Das Ergebnis seiner Operation ist folgendes:
s ist nicht gleich t, sie sind nicht dasselbe Objekt
Ich habe gerade eine kleine Änderung vorgenommen und das Ergebnis ist genau das Gegenteil des Beispiels gerade. Lassen Sie es uns noch einmal analysieren. Obwohl A und B als Konstanten definiert sind (nur einmal zugewiesen werden können), werden sie nicht sofort zugewiesen. Bevor der Wert von s berechnet wird, wann sie zugewiesen werden und welcher Wert ihnen zugewiesen wird, sind alles Variablen. Daher verhalten sich A und B wie eine Variable, bevor ihnen ein Wert zugewiesen wird. Dann können s nicht zur Kompilierzeit ermittelt, sondern erst zur Laufzeit erstellt werden.
Lassen Sie uns abschließend über die Speicherung von String-Objekten in der JAVA Virtual Machine (JVM) und die Beziehung zwischen dem String-Pool und dem Heap und Stack sprechen. Schauen wir uns zunächst den Unterschied zwischen Heap und Stack an:
Stapel: Speichert hauptsächlich Basistypen (oder integrierte Typen) (char, byte, short, int, long, float, double, boolean) und ist schneller als andere Haufen.
Heap: Wird zum Speichern von Objekten verwendet.
Wenn wir uns den Quellcode der String-Klasse ansehen, werden wir feststellen, dass er über ein Wertattribut verfügt, das den Wert des String-Objekts speichert. Der Typ ist char[], was auch zeigt, dass eine Zeichenfolge eine Folge von Zeichen ist. Beim Ausführen von String a="abc"; erstellt die virtuelle JAVA-Maschine drei Zeichenwerte „a“, „b“ und „c“ im Stapel und erstellt dann ein String-Objekt im Heap, dessen Wert (Wert) ist. ist ein Array aus drei gerade auf dem Stapel erstellten Zeichenwerten {'a', 'b', 'c'}. Schließlich wird das neu erstellte String-Objekt dem String-Pool hinzugefügt.
Wenn wir dann den String b=new String("abc");-Code ausführen, erstellt die virtuelle JAVA-Maschine nur ein neues String-Objekt im Heap, da „abc“ erstellt und gespeichert wurde value sind die drei char-Typwerte „a“, „b“ und „c“, die auf dem Stapel erstellt wurden, als die vorherige Codezeile ausgeführt wurde.
An diesem Punkt sind wir uns bereits ganz im Klaren über die Frage, warum String str=new String("abc"), der am Anfang dieses Artikels aufgeworfen wurde, zwei Objekte erzeugt.
Dieser Artikel stammt aus dem CSDN-Blog. Bitte geben Sie beim Nachdruck die Quelle an: http://blog.csdn.net/yakihappy/archive/2009/03/10/3977169.aspx
Dieser Artikel stammt aus dem CSDN-Blog. Bitte geben Sie beim Nachdruck die Quelle an: http://blog.csdn.net/Foxalien/archive/2009/12/18/5029470.aspx
-