StringBuilder vs. Stringverkettung

[Wildcard]

Wozu? Weil es lesbarer ist und mir eine millisekunde mehr oder weniger gelinde gesagt am Ar*** vorbei geht.
Oder willst du mir jetzt erzählen du nimmst diese 'Resultate' als Anlass dafür an unkritischen Stellen das '+' durch concat zu ersetzen? :shock:

 

[SlaterB]

// doppelt

 

[SlaterB]

bin ich verrückt? :bae:

es geht von Anfang an nur um die Aussage 'concat ist [ich wiederhole nicht die besprochenen Parameter] schneller als +'

du bist derjenige, der dagegen anredet

edit:
meine Frage 'Wozu?' bezog sich auf deinen Satz
> an kritischen Stellen nehme ich die Sache selbst mit Arrays, ByteBuffern oder StringBuildern in die Hand.
was nicht schneller als concat sein kann und gewiss nicht lesbarer
(in der Situation nur String + String, darum ging es da ja gerade)

 

[Wildcard]

meine Frage 'Wozu?' bezog sich auf deinen Satz
> an kritischen Stellen nehme ich die Sache selbst mit Arrays, ByteBuffern oder StringBuildern in die Hand.
was nicht schneller als concat sein kann und gewiss nicht lesbarer
(in der Situation nur String + String, darum ging es da ja gerade)

Wie bitte?
Es ist sogar extrem viel schneller. :shock:
Hier deinen Tester etwas vereinfacht wie man es richtig machen würde (und das ist der einzig interessante Fall):

public class StringTester
{
    static int k = 50000;

    public static void main(String[] args)
    {
        stringPlus1();
        stringConcat();
        stringPlus1();
        stringConcat();
        stringPlus1();
        stringConcat();

    }

    private static void stringPlus1()
    {
        long timeStart = System.currentTimeMillis();
        StringBuilder b = new StringBuilder();
        for (int i = k; i > 0; i--)
        {
            b.append(k);
        }
        String s = b.toString();
        System.out.println("String +1    : " + (System.currentTimeMillis() - timeStart));
    }


    private static void stringConcat()
    {
        long timeStart = System.currentTimeMillis();

        String s = "";
        for (int i = k; i > 0; i--)
        {

            s = s.concat(String.valueOf(k));

        }
        System.out.println("String.concat: " + (System.currentTimeMillis() - timeStart));
    }
}

Sieht dann so aus:

String +1    : 15
String.concat: 25735
String +1    : 15
String.concat: 25610
String +1    : 15

 

[SlaterB]

..
soll mir das jetzt neu sein oder wie?

also nochmal für dich nachgerückt

ich sagte
"für mich ist String + String aber 90% der Wichtigkeit, der einzig richtig sinnvolle Einsatz"
es geht also nur um
String stringA = stringB + stringC;

darauf sagst du
"Ich sehe dafür überhaupt keinen sinnvollen Einsatz. Gar keinen.
Wenn es sich nicht um eine kritische Stelle handelt mach ich String + String weil's einfacher und völlig egal ist, an kritischen Stellen nehme ich die Sache selbst mit Arrays, ByteBuffern oder StringBuildern in die Hand."

das habe ich interpretiert als
"an kritischen Stellen [für String stringA = stringB + stringC;] nehme ich die Sache selbst mit Arrays, ByteBuffern oder StringBuildern in die Hand."
und fragte "Wozu?"

du meintest offensichtlich was anderes, ist ja nicht schlimm,
aber dass ich nun concat() statt StringBuilder vorschlage ist ja eine gewagte Folgerung

 

[Wildcard]

Ja, ganz offensichtlich reden wir aneinander vorbei.

Für mich gibt es zu keiner Zeit eine Notwendigkeit concat aufzurufen. Jede Stelle bei der String + String steht ist so unkritisch, das es keine Rolle spielt.

 

[SlaterB]

dem stimme ich zu, benutze ich auch nie,

dennoch werde ich hier nicht von 'concat besser als +' abrücken, ätsch
(nur aus Geschwindigkeitssicht, natürlich nicht schön im Code usw)

 

[masta // thomas]

Mh.. könnte einer von euch lieben ein kurzes Résumé schreiben? Eigentlich möchte ich nur wissen - StringBuilder oder StringBuffer?

 

[SlaterB]

> Eigentlich möchte ich nur wissen

hattest du die Frage hier schonmal gestellt oder wie?

bei StringBuilder und Buffer gibts oberflächlich gesehen nicht viel zu nennen,
Buffer ist synchronized, also Thread-sicher und dafür bisschen langsamer,

wie viel, das kannst du in kleinen Testprogrammen testen, auch wenn Wildcard dich hauen würde
oder siehe Beispiele von Saxony auf der ersten Seite,
ist aber vergleichsweise irrelevant, ein kleines bisschen eben,

wenn du beim Programmieren bei 'StringBu' bist und weißt, dass nicht mehrere Threads gleichzeitig kommen werden,
dann sollten deine nächsten Buchstaben 'ilder' sein statt 'ffer', und schon sparst du ein paar unwesentliche Millisekunden,
mehr kann man dazu kaum sagen

 

[masta // thomas]

Das ist genau so eine Antwort, die ich erwartet habe super, danke SlaterB!

(Die Frage hab ich nicht schonmal gestellt aber vor lauter heissen Diskussionen hab ich irgendwann die Pointe überlesen / vergessen )

 

[Saxony]

Hiho,

naja da sind wir nun durch oder wie?

Mit dem Fazit:

StringA = StringB + StringA
ist langsamer als
StringA = StringA.concat(StringB)

und das alles ist noch langsamer als
StringBuffer
bzw.
StringBuilder

Weil falls das später mal jemand lesen sollte, will der nach 4 Seiten Diskussion auch mal ne Zusammenfassung sehen.

Zudem würde mich mal interessieren wie so eine Diskussion im Biergarten verlaufen wäre. Mit etwas Glück vielleicht auch ohne Handgreiflichkeiten!

Jaja Performance ist ein hartes Brot!!!

[edit]
Das nächste mal müssen wir mal vorher in einem Pflichtenheft festlegen worum es geht!
[/edit]

bye Saxony

 

[SlaterB]

zum Vergleich von + und concat nochmal:
es gibt noch einen wichtigen Fall (sofern man beim dem Thema überhaupt von wichtig sprechen kann),
in dem + überlegen ist:

bei der einfachen Addition mehrerer Strings, ohne einen großen Gesamtstring aufzubauen,
werden dabei mehr als 16 Zeichen zusammengefügt, sinkt der Vorteil von +, ist aber immer noch da,
concat kann in dem kleinen Bereich auch kaum durch Klammerung punkten, es sind eben n-1 einzelne Array-Erstellungen für n Teilstrings:

public class StringTester
{
    static int k = 9000000;
    static String st;

    public static void main(String[] args)
    {
        st = "12";

        stringPlus();
        stringConcat();
        stringConcat2();

        stringPlus();
        stringConcat();
        stringConcat2();

        st = "1234";

        stringPlus();
        stringConcat();
        stringConcat2();

        stringPlus();
        stringConcat();
        stringConcat2();

    }

    private static void stringPlus()
    {
        long timeStart = System.currentTimeMillis();
        String s = "";
        for (int i = k; i > 0; i--)
        {
            s = st + st + st + st + st + st;
        }
        System.out.println("\nString +      : " + (System.currentTimeMillis() - timeStart));
    }

    private static void stringConcat()
    {
        long timeStart = System.currentTimeMillis();

        String s = "";
        for (int i = k; i > 0; i--)
        {
            s = st.concat(st).concat(st).concat(st).concat(st).concat(st);
        }
        System.out.println("String.concat : " + (System.currentTimeMillis() - timeStart));
    }

    private static void stringConcat2()
    {
        long timeStart = System.currentTimeMillis();

        String s = "";
        for (int i = k; i > 0; i--)
        {
            s = st.concat(st).concat(st.concat(st)).concat(st.concat(st));
        }
        System.out.println("String.concat2: " + (System.currentTimeMillis() - timeStart));
    }
}

Ausgabe:


String +      : 3766
String.concat : 5673
String.concat2: 5516

String +      : 3735
String.concat : 5485
String.concat2: 5204

// ab hier > 16 Chars, schlechter für +

String +      : 4689
String.concat : 6001
String.concat2: 5516

String +      : 4688
String.concat : 5939
String.concat2: 5532

concat bleibt bei 2 Strings vorne,

im Bereich mehrerer Strings siehts für + aber nun deutlich besser aus,
ich sehe dort nun + in Führung, denn das hier angegebene Beispiel ist ja wirklich ein vergleichsweise wichtiges Feld

bei exotischen Situationen mit sehr großen Strings wäre concat() wieder besser (subjektiv)