Früher sah ich oft Diskussionen über Java -String -Spleißen und andere Aspekte im Internet. Ich habe einige Java -Entwickler in ihren Vorschlägen an Anfängerprogrammierer wie folgt gesehen:
Verwenden Sie das + Zeichen nicht, um Zeichenfolgen zu spleißen, und verwenden Sie die append () -Methode von StringBuffer oder StringBuilder, um Zeichenfolgen zu spleißen.
Es ist jedoch wirklich so nervig, Strings mit + Zeichen zu spleißen. Gibt es nichts Gutes daran, + Zeichen zu verwenden, um Strings zu spleißen?
Indem wir einige Inhalte über die String -Klasse in der Java -API -Dokumentation suchen, können wir den folgenden Snippet sehen:
"Die Java -Sprache bietet eine besondere Unterstützung für String -Verkettungssymbole ("+") und die Konvertierung anderer Objekte in Zeichenfolgen. String -Verkettung wird über die StringBuilder -Klasse (oder StringBuffer) -Klasse und ihre Anhangsmethode implementiert. String -Konvertierung wird durch die Tostring -Methode implementiert, die von der Objektklasse definiert wird und von allen Klassen in Java -Klassen in den Haftklassen definiert wird."
Diese Passage zeigt uns deutlich, dass in Java + Sign Spleißstrings tatsächlich von StringBuffer oder StringBuilder und seiner Anhangsmethode implementiert wird.
Zusätzlich zur Java -API -Dokumentation können wir das Tool verwenden, um den Befehl bytecode der Klassendatei anzuzeigen, um die obige Antwort zu erhalten. Zum Beispiel Code:
public static void main (String [] args) {String a = "Hallo"; Zeichenfolge b = "Welt"; String str = a + b + "!"; System.out.println (str);} Der Befehl zum Anzeigen des entsprechenden Bytecode durch das Tool lautet wie folgt:
Aus dem Befehl bytecode können wir deutlich sehen, dass der folgende Code, den wir geschrieben haben
String str = a + b + "!";
Es wurde in eine ähnliche Aussage umgewandelt: Folgendes:
String str = new StringBuilder (string.ValueOf (a)). Append (b) .Append ("!"). ToString ();Darüber hinaus ist der Java -Compiler auch ein relativ intelligenter Compiler. Wenn das Spleiß von + Zeichen alle String -Literale ist, wandelt es der Java -Compiler während der Zusammenstellung intelligent in eine vollständige Zeichenfolge um. Zum Beispiel:
public static void main (String [] args) {String str = "Hallo" + "Welt" + ", Java!"; System.out.println (str);} Der Java -Compiler spleißt diese Art von Saite, die buchstäblich ist, direkt auf und wandelt sie beim Kompilieren in eine vollständige Zeichenfolge um.
Selbst wenn es Variablen im String mit + -Schild gibt, fusioniert der Java -Compiler die vorderen String -Literale in eine Zeichenfolge.
public static void main (String [] args) {String java = ", Java!"; String str = "Hallo" + "Welt" + Java; System.out.println (str);}Aus dem obigen oben ist ersichtlich, dass für eine Operation wie String str = str1 + str2 + str3 + str4 kein Problem beim Spleißen mehrerer Strings gleichzeitig gibt.
In Java sind String -Objekte unveränderlich (unveränderlich). Im Code können Sie mehrere Aliase für ein bestimmtes String -Objekt erstellen. Die Referenzen dieser Aliase sind jedoch gleich.
Zum Beispiel sind S1 und S2 Alias für "droidyue.com" -Objekte, und die Alias werden in Bezug auf das reale Objekt gespeichert. Also S1 = S2
String s1 = "droidyue.com"; String S2 = S1; System.out.println ("S1 und S2 hat dieselbe Referenz =" + (S1 == S2));Und in Java bezieht sich der einzige überlastete Operator mit String -Spleißen. +,+=. Außerdem erlauben Java -Designer keine Überladung anderer Bediener.
In Java bezieht sich der einzige überladene Operator mit String -Spleißen. +,+=. Außerdem erlauben Java -Designer keine Überladung anderer Bediener.
Wie wir alle wissen, könnte vor Java 1.4 Stringnähen verwendet werden, um Strings zu spleißen. Ab Java 1.5 können wir StringBuilder verwenden, um Saiten zu spleißen. Der Hauptunterschied zwischen StringBuffer und StringBuilder besteht darin, dass StringBuffer mit Thread-safe ist und für die Multi-Thread-Betrieb von Zeichenfolgen geeignet ist. StringBuilder ist thread-sicher und eignet sich für Betriebszeichenfolgen unter einem einzelnen Faden. Die meisten unserer String -Stitching -Operationen werden jedoch unter einem einzelnen Thread durchgeführt, sodass die Verwendung von StringBuilder für die Leistung von Vorteil ist.
Vor Java 1.4 verwendete der Compiler StringBuffer, um Saiten mit + Zeichen gespleißten Zeichenfolgen zu behandeln. Ab Java 1.5 verwendete der Compiler StringBuilder, um Strings mit + Zeichen gespleißten Zeichenfolgen zu behandeln.
Wenn wir Code in der Umgebung von JDK 1.4 schreiben, wird empfohlen, das + -Schark zu verwenden, um die obige Situation zu behandeln, in der mehrere Zeichenfolgen gleichzeitig gespleißt werden. Wenn JDK auf 1,5 und höher aktualisiert wird, wandelt der Compiler ihn automatisch in StringBuilder in Spleißketten um, wodurch die Effizienz des Stringspleißens verbessert wird.
Natürlich ist die empfohlene Verwendung von + Zeichenspleißstrings nur darauf beschränkt, wenn Sie mehrere Zeichenfolgen in einer Anweisung spleißen. Wenn Sie eine Zeichenfolge in mehreren Anweisungen spleißen, wird weiterhin empfohlen, StringBuffer oder StringBuilder zu verwenden. Zum Beispiel:
public static void main (String [] args) {String java = ", Java!"; String str = ""; STR += "Hallo"; Str += "Welt"; STR += Java; System.out.println (str);} Die kompilierten Byte -Befehle des Compilers sind wie folgt:
Aus dem obigen Bild können wir wissen, dass jede Anweisung + Zeichen Spleißanweisung ein neues StringBuilder -Objekt erstellt. Diese Situation zeigt sich besonders unter Zyklusbedingungen, was zu relativ großen Leistungsverlusten führt. Daher wird dringend empfohlen, StringBuffer oder StringBuilder zu verwenden, um Zeichenfolgen in mehreren Anweisungen zu verarbeiten.
Über die Optimierung, die durch die Verwendung von StringBuilder mitgebracht wurde
Bei Verwendung von StringBuffer oder StringBuilder können wir außerdem die folgende Methode verwenden, um die Leistung weiter zu verbessern (der folgende Code nimmt als Beispiel für StringBuffer ähnlich).
1. Vorhersage die maximale Länge der endgültigen erhaltenen Zeichenfolge.
Die Standardlänge des Zeichen -Arrays in StringBuilder beträgt 16. Wenn wir die Zeichenfolge anhängen und diese Länge überschreiten, erweitert StringBuilder die interne Array -Kapazität, um die Anforderungen zu erfüllen. In diesem Prozess erstellt StringBuilder ein neues Charakter mit größerer Kapazität und kopiert die Daten aus dem ursprünglichen Array in das Neue Array. Wenn wir die maximale Länge der schließlich gespleißten Zeichenfolge grob vorhersagen können, können wir beim Erstellen des StringBuilder -Objekts die anfängliche Kapazität der entsprechenden Größe angeben. Zum Beispiel müssen wir uns spleißen, um eine Zeichenfolge mit 100 Buchstaben a zu erhalten. Sie können den folgenden Code schreiben:
StringBuilder sb = new StringBuilder (100); für (int i = 0; i <100; i ++) {sb.append ('a');} System.out.println (SB);Bitte gleichen Sie gemäß den tatsächlichen Bedingungen aus, um einen StringBuilder zu erstellen, der für die Anfangskapazität geeignet ist.
2. Verwenden Sie für einzelne Zeichen den Zeichenentyp anstelle des String -Typs so weit wie möglich.
Manchmal müssen wir ein einzelnes Zeichen nach der Zeichenfolge anhängen (zum Beispiel: a), und wir sollten es zu diesem Zeitpunkt so weit wie möglich verwenden.
sb.Append ('a');Anstatt zu verwenden:
sb.Append ("a");