Wie Java tun, die string-Verkettung mit "+"?

Wenn Sie kombinieren wörtliche strings (wörtlich "foo" + "bar"), der compiler ist es zur Kompilierzeit, nicht zur Laufzeit.

Wenn Sie zwei nicht-Literale Zeichenfolgen und fügen Sie Sie mit + der compiler (Sonne sowieso), wird ein StringBuilder unter der Decke, aber nicht unbedingt der effizienteste Weg. So zum Beispiel, wenn Sie haben diese:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv += a;
    }
    return rv;
}

...was die Sonne compiler tatsächlich produzieren als bytecode sieht etwas wie diese:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv = new StringBuilder().append(rv).append(a).toString();
    }
    return rv;
}

(Ja, wirklich — siehe die Demontage am Ende dieser Antwort.) Beachten Sie, dass es ein neues StringBuilder bei jeder iteration, und dann in der Folge zu String. Dies ist ineffizient (aber es spielt keine Rolle, es sei denn, du machst es einem viel), weil alle temporären Speicher-Zuweisungen: Es weist eine StringBuilder und den Puffer, womöglich neu reserviert, die Puffer auf dem ersten append [wenn rv mehr als 16 Zeichen lang sein, was ist die default buffer size] und wenn nicht der erste dann fast sicher auf dem zweiten append, dann reserviert einen String am Ende — und dann tut es alle wieder für die nächste iteration.

Konnten Sie gewinnen Effizienz, wenn nötig, schreiben Sie es explizit eine StringBuilder:

String repeat(String a, int count) {
    StringBuilder rv;

    if (count <= 0) {
        return "";
    }

    rv = new StringBuilder(a.length() * count);
    while (count-- > 0) {
        rv.append(a);
    }
    return rv.toString();
}

Dort haben wir eine explizite StringBuilder und auch seine erste Puffer-Kapazität groß genug sein, um das Ergebnis aufzunehmen. Das ist mehr Speicher-effizient, aber natürlich geringfügig weniger klar zu unerfahren code-maintainer und unwesentlich mehr wie ein Schmerz zu schreiben. So wenn finden Sie ein performance-Problem mit einem knappen string-concat-Schleife, könnte dies ein Weg, um es anzugehen.

Können Sie sehen, dieses unter-dem-Deckel StringBuilder in Aktion mit dem folgenden test Klasse:

public class SBTest
{
    public static final void main(String[] params)
    {
        System.out.println(new SBTest().repeat("testing ", 4));
        System.exit(0);
    }

    String repeat(String a, int count) {
        String rv;

        if (count <= 0) {
            return "";
        }

        rv = a;
        while (--count > 0) {
            rv += a;
        }
        return rv;
    }
}

...die zerlegt (mit javap -c SBTest) wie folgt:

Compiled from "SBTest.java"
public class SBTest extends java.lang.Object{
public SBTest();
Code:
   0: aload_0
   1: invokespecial  #1; //Method java/lang/Object."<init>":()V
   4: return

public static final void main(java.lang.String[]);
Code:
   0: getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   3: new   #3; //class SBTest
   6: dup
   7: invokespecial  #4; //Method "<init>":()V
   10: ldc   #5; //String testing
   12: iconst_4
   13: invokevirtual  #6; //Method repeat:(Ljava/lang/String;I)Ljava/lang/String;
   16: invokevirtual  #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   19: iconst_0
   20: invokestatic   #8; //Method java/lang/System.exit:(I)V
   23: return

java.lang.String repeat(java.lang.String, int);
Code:
   0: iload_2
   1: ifgt  7
   4: ldc   #9; //String
   6: areturn
   7: aload_1
   8: astore_3
   9: iinc  2, -1
   12: iload_2
   13: ifle  38
   16: new   #10; //class java/lang/StringBuilder
   19: dup
   20: invokespecial  #11; //Method java/lang/StringBuilder."<init>":()V
   23: aload_3
   24: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   27: aload_1
   28: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   31: invokevirtual  #13; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   34: astore_3
   35: goto  9
   38: aload_3
   39: areturn

}

Hinweis, wie eine neue StringBuilder erstellt jeder iteration der Schleife und erstellt mit der Standard-Puffer-Kapazität.

Alle diese vorläufige Zuweisung Zeug klingt hässlich, aber auch nur, wenn man sich mit erhebliche Schleifen und/oder erhebliche strings. Auch, wenn der resultierende bytecode wird ausgeführt, die JVM kann auch weiter optimieren. Sun HotSpot JVM, zum Beispiel, ist ein sehr reifer JIT-compiler-Optimierung. Sobald es identifiziert die Schleife als ein hot spot, und es kann auch einen Weg finden, es umgestalten. Oder natürlich nicht. 🙂

Meine Faustregel ist, ich Sorge mich um Sie, wenn ich ein performance-problem, oder wenn ich weiß, ich bin ein viel der Verkettung und es ist sehr wahrscheinlich ein performance-problem und der code wird nicht erheblich beeinträchtigt sein, von einem Wartbarkeit Standpunkt, wenn ich einen StringBuilder statt. Den fanatischen anti-vorzeitiger-Optimierung Liga würde wahrscheinlich nicht mit mir übereinstimmen, auf die zweite. 🙂

Für die Verkettung eine Feste Anzahl von strings in einem Ausdruck mit + erzeugt der compiler code mit einem einzigen StringBuilder.

E. g. die Linie

String d = a + b + c;

Ergebnisse in den gleichen bytecode, wie die Linie

String d = new StringBuilder().append(a).append(b).append(c).toString();

beim kompilieren mit dem javac-compiler. (Der Eclipse-compiler erzeugt etwas mehr optimierten code durch aufrufen new StringBuilder(a) spart so eine Methode aufrufen.)

Wie bereits in anderen Antworten, wird der compiler verketten von string-literalen wie "a" + "b" in einem string selbst, die bytecode enthält "ab" statt.

Wie erwähnt überall im Netz, sollten Sie nicht verwenden + zum Aufbau eines string innerhalb einer Schleife, weil Sie das kopieren der Anfang der Zeichenkette, über und über, um neue Saiten. In dieser situation sollten Sie eine StringBuilder dem Sie erklären, außerhalb der Schleife.

Saiten sind Häufig verkettet
mit dem + - operator, wie in
"Hello," + " world" + "!"

Quelle