Sie können den Operator '+', um zwei oder mehr Zeichenfolgen zu verketten, ist dies der einfachste Weg, die Arbeit zu erledigen. Beispiel: "Eins" + "Zwei" erzeugt das String-Objekt "EinsZwei". Sie können diesen Operator verwenden, um mindestens zwei Strings zu kombinieren, zum Beispiel: "ab"+"cde"+fghi" ergibt "abcdefghi", und Sie können auch String-Variablen verwenden.
Diese Operation wird vom Compiler umgewandelt in:

new StringBuilder().append("string1").append("string2").toString()

Dieses Programm verkettet zwei Strings:

public class Concatenation_string {
 public static void main(String[] args) {
 String s1 = "string1"; 
 Zeichenkette s2 = "Zeichenfolge2"; 
 
 Zeichenkette s1s2 = concatenation_strings_java(s1, s2); 
 System.out.println(s1s2); 
 }
 
 public static String concatenation_strings_java (String s1, String s2) {
 return s1+s2; 
 }
}

Laufzeit:

string1chain2

Verketten Sie Zeichenfolgen mit der Methode String.concat()

Diese Methode verkettet einen String am Ende eines anderen. Die Methode gibt einen String mit dem Wert von String zurück, der in der verketteten Methode übergeben wird, mit dem Ende des Strings, der zum Aufrufen dieser Methode verwendet wird.

public String concat(String s)

Example:

public class Concatenation_string {
 public static void main(String[] args) {< br /> String s = "Ich bin einer"; 
 s = s.concat(" programmierer"); 
 System.out.println(s); 
 }
}

Laufzeit:

Ich bin Programmierer

Unterschied zwischen dem Operator '+' und der Methode String.concat()

Um den Unterschied zwischen dem Operator '+' und die concat() werden wir mit einem praktischen Beispiel arbeiten.

a+=b
a.concat(b)

Zunächst gibt es einen kleinen Unterschied in der Semantik. Wenn a null, dann a.concat(b) löst eine NullPointerException, aber die '+' in der Anweisung a+=b verarbeitet den Wert von a auch wenn es null. Darüber hinaus kann die Methode concat() akzeptiert nur String-Werte, während der '+'-Operator den Wert mit dem toString() ). Wir können sagen, dass die Methode concat() ist strenger, da es akzeptiert.

Sie können diesen Code schreiben und sehen, was Sie in output:

public static void main(String[] args) {
 String s = null; 
 s = s.concat(" programmierer"); 
 System.out.println(s); 
}

Sie sollten dies zur Laufzeit haben:

Ausnahme im Thread "main" java.lang.NullPointerException
 at Concatenation_string.main(Concatenation_string.java:5)

Das gleiche Beispiel mit dem Operator '+':

public static void main(String[] args) {
 String s = null; 
 s = s + Programmierer; 
 System.out.println(s); 
}

Sie sollten folgendes Ergebnis haben:

nullprogrammer

Wie bereits erwähnt, ist der Operator '+' ist äquivalent zu:

a = new StringBuilder()
 .append(a)
 .append(b)
 .toString(); 

Verketten von Zeichenfolgen mit StringBuffer und StringBuilder

Diese Art der Verkettung reduziert die Speicher- und Zeitkosten, da keine String-Objekte generiert werden. Tatsächlich sollten Sie immer StringBuilder anstelle von StringBuffer verwenden, da es die gleiche Funktionalität hat, jedoch ohne Synchronisierung, was einen schnelleren Vorgang bedeutet. Die Verwendung von StringBuffer oder StringBuilder führt auch zu strukturiertem Code, wie unten gezeigt:

String result = new StringBuilder(15).append(name).append(" ").append(firstname).toString(); 

Sie können sehen, wie einfach es ist, mehrere Strings mit StringBuilder zu verketten. Denken Sie jedoch daran, StringBuilder mit einer Kapazität zu initialisieren, die der Anzahl der Zeichen in der letzten Zeichenfolge entspricht. Dies verhindert, dass unbrauchbarer Speicher verloren geht, indem unser String ordnungsgemäß initialisiert wird, und reduziert die CPU-Zeit.

Hier ist ein Beispiel für ein Java-Programm, das Ihnen zeigt, wie Sie einen String mit StringBuilder und StringBuffer verketten.

public static void main(String[] args) {
 String court ="Court of"; 
 Zeichenfolge module_math ="math"; 
 
 /* StringBuilder */
 String module_res = "networks"; 
 int length = court.length()+module_math.length(); 
 StringBuilder sb = new StringBuilder(length); 
 sb.append(court).append(module_math); 
 String res = sb.toString(); 
 System.out.println(res); 
 
 /* StringBuilder */
 length = court.length()+module_math.length(); 
 StringBuffer sBuffer = new StringBuffer(length); 
 sb.append(" und").append(court).append(module_res); 
 res = sb.toString(); 
 System.out.println(res); 
}

Output:

 Math Courtyard
 Math Courtyard and Network Courtyard

Performance of String Concatenation in Java

Es ist klar, dass der einfachste und schnellste Weg, Strings zu verketten, die Verwendung des Operators '+' ist Und es funktioniert sehr gut, wenn Sie nur zwei Strings haben, aber wenn Sie Tausende von Strings verketten müssen, insbesondere innerhalb einer Schleife, dann nimmt die Leistung mit dem Operator '+' ab. Die Ursache für die schlechte Leistung ist die Erstellung temporärer Batches für String-Objekte. Wenn Sie viele Strings in Ihrem Programm haben, können Sie die folgenden Ergebnisse sehen, die zeigen, dass die beste Möglichkeit für eine groß angelegte Verkettung darin besteht, die Klasse StringBuilder. Diese Statistiken wurden in einer Windows 7 64-Bit-Umgebung mit Core 2 Duo-Prozessor (2,53 GHz) mit 4 GB RAM erstellt.

public static void main(String[] args) {
 int nb_op=10000; 
 Zeichenfolge s=""; 
 
 double t1,t2,time; 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 s += "*"; 
 t2 = System.currentTimeMillis(); 
 Zeit = t2-t1; 
 System.out.println("+: "+Zeit); 
 
 s=""; 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 s.concat("*"); 
 t2 = System.currentTimeMillis(); 
 Zeit = t2-t1; 
 System.out.println("concat: "+time); 
 
 StringBuilder sb=new StringBuilder(); 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 sb.append("*"); 
 t2 = System.currentTimeMillis(); 
 Zeit = t2-t1; 
 System.out.println("StringBuilder: "+time); 
 
 StringBuffer sBuffer=new StringBuffer(); 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 sBuffer.append("*"); 
 t2 = System.currentTimeMillis(); 
 Zeit = t2-t1; 
 System.out.println("StringBuffer: "+time); 
}

Ergebnisse für 10000 Verkettungsoperationen:

+: 180.0
concat: 13.0
StringBuilder: 2.0
StringBuffer: 4.0

Zeit in Millisekunden für 10000 Operationen

Ein weiteres Diagramm, das die erreichte Zeit in Abhängigkeit von der Anzahl der Operationen zeigt:


Der erste Eindruck ist erstaunlich! Hier stellen wir sofort fest, dass die vom Operator '+' erreichte Zeit proportional zur Anzahl der Verkettungsvorgänge ist und er zehn Sekunden für 100000 Operationen durchgeführt hat. Daher ist der "+"-Operator eine sehr schlechte Wahl, wenn Sie an einem Großprojekt arbeiten. concat, StringBuilder und StringBuffer sind für den '+'-Operator unsichtbar, aber Sie können in der Statistiktabelle sehen, dass StringBiulder weniger Zeit benötigt hat.

Die Methode  concat()  ist schnell. Die Verkettung mehrerer Strings erfolgt jedoch mit der StringBuilder-Methode in Bezug auf die Performance schneller.

Der Quellcode für String und StringBuilder ist im Sun JDK verfügbar. Sie können sehen, dass Sie ein Tankboard bauen. Die Speicherzuweisung ist superschnell.

Denken Sie daran:

• Verwenden Sie niemals den Operator + in einer Schleife.
• Verwenden Sie immer StringBuilder zum Verketten mehrerer Strings.
• Initialisieren Sie immer die Größe von StringBuilder.

Referenzen:
Java - String concat() Methode
String-Verkettung: concat() vs + operator
Java - String Buffer append() Methode