StringBuilder gegen String-Konkatenation in toString() in Java

Question

Angesichts der beiden unten stehenden toString()-Implementierungen, welche ist bevorzugt:

public String toString(){
    return "{a:"+ a + ", b:" + b + ", c: " + c +"}";
}

oder

public String toString(){
    StringBuilder sb = new StringBuilder(100);
    return sb.append("{a:").append(a)
          .append(", b:").append(b)
          .append(", c:").append(c)
          .append("}")
          .toString();
}

?

Noch wichtiger ist, dass wir nur 3 Eigenschaften haben und es keinen Unterschied machen könnte, aber ab wann würden Sie von der Verwendung von + für die Konkatenierung zu StringBuilder wechseln?

Answer 1

Version 1 ist vorzuziehen, weil es kürzer ist und der Compiler es tatsächlich in Version 2 umwandeln wird - keinerlei Leistungsunterschied.

Viel wichtiger ist, dass wir nur 3 Eigenschaften haben, daher könnte es keinen Unterschied machen, aber ab wann wechseln Sie vom Konkatenieren zum Builder?

An dem Punkt, an dem Sie in einer Schleife konkatenieren - das ist normalerweise, wenn der Compiler StringBuilder nicht von alleine ersetzen kann.

Answer 2

Der Schlüssel liegt darin, ob Sie eine einzelne Konkatenation an einem Ort schreiben oder sie im Laufe der Zeit ansammeln.

Für das von Ihnen gegebene Beispiel macht es keinen Sinn, explizit StringBuilder zu verwenden. (Schauen Sie sich den kompilierten Code für Ihren ersten Fall an.)

Aber wenn Sie einen String z.B. innerhalb einer Schleife aufbauen, verwenden Sie StringBuilder.

Zur Klarstellung, vorausgesetzt, hugeArray enthält Tausende von Strings, ist Code wie dieser:

...
String result = "";
for (String s : hugeArray) {
    result = result + s;
}

sehr zeitaufwändig und speicherintensiv im Vergleich zu:

...
StringBuilder sb = new StringBuilder();
for (String s : hugeArray) {
    sb.append(s);
}
String result = sb.toString();

Answer 3

In den meisten Fällen werden Sie keinen tatsächlichen Unterschied zwischen den beiden Ansätzen sehen, aber es ist leicht, ein Worst-Case-Szenario wie dieses zu konstruieren:

public class Main
{
    public static void main(String[] args)
    {
        long now = System.currentTimeMillis();
        slow();
        System.out.println("slow elapsed " + (System.currentTimeMillis() - now) + " ms");

        now = System.currentTimeMillis();
        fast();
        System.out.println("fast elapsed " + (System.currentTimeMillis() - now) + " ms");
    }

    private static void fast()
    {
        StringBuilder s = new StringBuilder();
        for(int i=0;i<100000;i++)
            s.append("*");      
    }

    private static void slow()
    {
        String s = "";
        for(int i=0;i<100000;i++)
            s+="*";
    }
}

Die Ausgabe ist:

slow elapsed 11741 ms
fast elapsed 7 ms

Das Problem ist, dass += zum Anhängen an einen String einen neuen String rekonstruiert, so dass es etwas kostet, das linear zur Länge Ihrer Strings (Summe beider) ist.

Also - zu Ihrer Frage:

Der zweite Ansatz wäre schneller, aber er ist weniger lesbar und schwerer zu warten. Wie gesagt, in Ihrem speziellen Fall würden Sie wahrscheinlich keinen Unterschied sehen.

Answer 4

Ich bevorzuge:

String.format( "{a: %s, b: %s, c: %s}", a, b, c );

...weil es kurz und lesbar ist.

Ich würde dies nicht für Geschwindigkeit optimieren, es sei denn, Sie verwenden es in einer Schleife mit einer sehr hohen Wiederholungszahl und haben den Leistungsunterschied gemessen.

Ich stimme zu, dass diese Form bei der Ausgabe vieler Parameter verwirrend sein kann (wie einer der Kommentare sagt). In diesem Fall würde ich zu einer lesbareren Form wechseln (vielleicht unter Verwendung von ToStringBuilder von Apache Commons - entnommen aus der Antwort von matt b) und die Leistung erneut ignorieren.

Answer 5

Seit Java 1.5 generieren einfache einzeilige Verkettungen mit "+" und StringBuilder.append() genau den gleichen Bytecode.

Also verwenden Sie zur besseren Lesbarkeit des Codes "+".

2 Ausnahmen :

• mehrfädige Umgebung : StringBuffer
• Verkettung in Schleifen : StringBuilder/StringBuffer