it-swarm.com.de

Bewährte Verfahren/Leistung: Mischen von StringBuilder.append mit String.concat

Ich versuche zu verstehen, was die beste Vorgehensweise ist und warum für das Verketten von String-Literalen und -Variablen für verschiedene Fälle. Zum Beispiel, wenn ich so einen Code habe

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String).append("CCCCCCCCCCC").append(D_String)
    .append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

Ist dies der Weg, dies zu tun? In this post habe ich festgestellt, dass der +-Operator für Strings eine neue Instanz von StringBuilder erstellt, die Operanden verkettet und eine String-Konvertierung zurückgibt, die viel mehr Arbeit als den Aufruf von .append() darstellt. Wenn das also stimmt, steht das nicht in Frage. Aber was ist mit String.concat()? Ist es richtig, .append() für jede Verkettung zu verwenden? Oder nur für Variablen, und Literale können mit .concat() angehängt werden?

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String.concat("CCCCCCCCCCC")).append(D_String
    .concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));

Welches sind die allgemeinen Regeln für Best Practices und Leistung, um in diesen Situationen vorzugehen? Stimmt meine Annahme in + und sollte sie eigentlich nicht verwendet werden?

80
Nick Rolando

_+_ Operator

_String s = s1 + s2
_

Hinter den Kulissen heißt das übersetzt:

_String s = new StringBuilder(s1).append(s2).toString();
_

Stellen Sie sich vor, wie viel zusätzliche Arbeit hinzugefügt wird, wenn Sie _s1 + s2_ hier haben:

_stringBuilder.append(s1 + s2)
_

anstatt:

_stringBuilder.append(s1).append(s2)
_

Mehrere Zeichenfolgen mit _+_

Es ist zu beachten, dass:

_String s = s1 + s2 + s3 + ... +sN
_

übersetzt in:

_String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();
_

concat()

_String s = s1.concat(s2);
_

String erstellt ein _char[]_-Array, das sowohl für _s1_ als auch für _s2_ geeignet ist. Kopiert den Inhalt von _s1_ und _s2_ in dieses neue Array. Benötigt weniger Arbeit als der Operator _+_.

StringBuilder.append()

Verwaltet ein internes _char[]_ Array, das bei Bedarf erweitert wird. Es wird kein zusätzlicher _char[]_ erstellt, wenn der interne ausreichend groß ist.

_stringBuilder.append(s1.concat(s2))
_

die Leistung ist ebenfalls schlecht, da s1.concat(s2) ein zusätzliches _char[]_-Array erstellt und _s1_ und _s2_ dorthin kopiert, nur um den neuen Array-Inhalt in das interne StringBuilder _char[]_ zu kopieren.

Davon abgesehen sollten Sie append() die ganze Zeit verwenden und unformatierte Zeichenfolgen anhängen (Ihr erstes Code-Snippet ist korrekt).

175

Der Compiler optimiert die + Verkettung.

So

int a = 1;
String s = "Hello " + a;

verwandelt sich in

new StringBuilder().append("Hello ").append(1).toString();

Es gibt ein ausgezeichnetes Thema hier Erklären, warum Sie den Operator + verwenden sollten.

15
user973999

Die Optimierung erfolgt automatisch vom Compiler.

Der Java2-Compiler konvertiert automatisch Folgendes:

String s = s1 + s2; 

zu

String s = (new StringBuffer()).append(s1).append(s2).toString();

Direkt von der Java Best Practices auf der Oracles-Website übernommen.

3
BoldAsLove

Sie sollten immer append verwenden.

concat erstellt einen neuen String, also ist es ziemlich +, denke ich.

Wenn Sie concat oder + mit 2 final String verwenden, kann die JVM eine Optimierung vornehmen. In diesem Fall ist dies dasselbe wie das Anhängen.

2
alain.janinm

Wenn Sie genau zwei Strings verwenden, verwenden Sie String.concat (erstellt einen neuen String, indem Sie ein neues Char-Array erstellen, das sowohl Strings passt als auch die Char-Arrays beider Strings kopiert).

Wenn Sie mehrere (mehr als zwei) Zeichenfolgen in einer Zeile zusammenfassen, verwenden Sie + oder StringBuilder.append. Dies spielt keine Rolle, da der Compiler + in StringBuilder.append konvertiert. Dies ist für mehrere Strings geeignet, da ein Zeichen-Array beibehalten wird, das bei Bedarf wächst.

Wenn Sie mehrere Strings über mehrere Zeilen verteilen, erstellen Sie einen StringBuilder und verwenden Sie die append-Methode. Wenn Sie mit dem Anhängen von Strings an den StringBuilder fertig sind, verwenden Sie die .toString () - Methode, um daraus einen String zu erstellen. __ Für das Zusammenfügen in mehreren Zeilen ist dies schneller als die zweite Methode, da die zweite Methode die zweite Methode erstellen würde Fügen Sie in jeder Zeile einen neuen StringBuilder ein, hängen Sie die Strings an und wandeln Sie sie wieder in String um, während die dritte Methode nur einen StringBuilder für das Ganze verwendet.

1
Dakkaron

Der +-Operator ist eine bewährte Methode, er ist einfach und lesbar.

Die Java-Sprache bietet spezielle Unterstützung für die Zeichenfolge Verkettungsoperator (+) und zur Konvertierung anderer Objekte in Streicher String-Verkettung wird über die .__ implementiert. StringBuilder (oder StringBuffer) -Klasse und ihre Append-Methode.

Offizielles Dokument: https://docs.Oracle.com/javase/8/docs/api/Java/lang/String.html

0
foobarfuu

in Byte-Code-Ebene gibt es keine Unterschiede, und wir beeinträchtigen die Effizienz dort nicht. Im Falle der Ausführung des Bytecode-Levels muss für + eine nicht inline-Operatorüberladungsmethode durch Aufruf von append durchlaufen werden. dann auf Assembly-Sprachebene (Java ist in C geschrieben, und C erstellt Assemblys, die der Assembly ähnlich sind, es wird ein zusätzlicher Registeraufruf zum Speichern von + Methodenaufruf im Stack und es wird zusätzlicher Push. (In Wirklichkeit kann der Cross-Compiler den Operator + optimieren anrufen, in diesem Fall macht es keinen Unterschied mit der Effizienz.)

Es bietet sich an, auf eine Weise die Lesbarkeit zu erhöhen. :)

0
Shevon Silva