String erzeugen sehr langsam

[Thallius]

Hallo,

ich erzeuge einen sehr langen String, welcher danach in en CSV File gepseichert wird.
Leider dauert das Erzeugen des Strings bei rund 12000 Zeilen und 8 Spalten fast 5min. Das kann es ja nicht sein. Der Code ist denkbar einfach

    String text = "";

    int rows = model.getRowCount();
    int columns = model.getColumnCount();

    for(int i = 0; i < rows; i++)
    {
           for(int j = 0; j < columns; j++)
           {
                  String value = (String) model.getValueAt(i, j);
                  if(value != null)
                       text+="=\""+value+"\"";
                    if(j < rows - 1)
                        text+=";";
            }
            text+="\r\n";
     }

Wenn ich die Zeilen mit text+= entferne läuft die Schleife in einem Bruchteil einer Sekunde durch. Sobald ich die erhaltene Werte an den String anhänge wird es unerträglich langsam.

Warum ist das? Was kann man ändern?

Gruß

Claus

 

[SchwarzWeiß]

Beim Anhängen wird immer ein neues String-Objekt erstellt. Du solltest daher anstatt String den StringBuilder verwenden.

 

[stg]

Hast du's mal mit einem StringBuilder probiert? Eventuell die anfängliche Größe zu Beginn hoch ansetzen, um viel Bit-Schubserei beim implziten vergrößern zu vermeiden?
Oder einfach alle X Zeilen bereits in die Datei schreiben und parallel dazu direkt die nächsten X Zeilen "berechnen"'.
Das Problem lässt sich übrigens auch prima parallelisieren, falls das eine Option ist. Da musst du dann natürlich nur beim Schreiben aufpassen.
Ich hab keine Erfahrungswerte, was tatsächlich am schnellsten ist, aber das wären Möglichkeiten, die du mal mit wenig Aufwand durchprobieren könntest. Insbesondere die erste einfache Variante kann schon sehr viel bringen. Da wird zwar intern schon viel implizit optimiert und für die Konkatenierung von Strings ohnehin der gleiche Bytecode generiert, wie bei der direkten Verwendung eines StringBuilders, aber ich kann mir vorstellen, dass "Java" da nicht alle Optimierungsmöglichkeiten sieht bei der gegebenen Verschachterlung

 

[Viktim]

+= Erzeugt jedesmal einen neuen String wärend der Stringbuilder den alten bearbeitet

 

[InfectedBytes]

+= Erzeugt jedesmal einen neuen String wärend der Stringbuilder den alten bearbeitet

nicht ganz, der StringBuilder bearbeitet keinen alten String, sonder er speichert die chars in einem Array. Falls das Array zu klein wird, wird eben ein größeres erstellt und die Daten rüberkopiert. Wenn man mit dem einfügen fertig ist, wird ein einzelner String erzeugt.

 

[Viktim]

jap, und der string wird halt nach jedem '+' neu erzeugt

 

[stg]

Nach jedem + definitiv nicht (siehe mein Einwand oben). Nach jedem += möglicherweise ja, da bin ich nicht sicher, wie schlau der Compiler da tatsächlich ist.

 

[InfectedBytes]

im Grunde nutzt der Compiler auch einen StringBuilder, aber eben für jedes statement ein neuen:

x = stringA + stringB + stringC;

wird im Grunde zu

StringBuilder sb = new StringBuilder();
sb.append(stringA);
sb.append(stringB);
sb.append(stringC);
x = sb.toString();

 

[Viktim]

Ich meiner er sagt bei:

String a = b + c + d;

das:

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

 

[Joose]

Zum Thema: Bei Verkettungen von Strings in Schleifen sollte man zwecks Performance auf den StringBuilder setzen.

Hier eine genauere Erklärung bezüglich concat und +-Operator:
http://stackoverflow.com/questions/47605/string-concatenation-concat-vs-operator

 

[InfectedBytes]

Ich meiner er sagt bei:

String a = b + c + d;

das:

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

Definitiv nicht, zumal du a benutzt obwohl du es gerade erst definierst.
Schau dir notfalls einfach den bytecode an, dann siehst du das folgendes passiert:

public static String test(String a, String b, String c) {
    return a+b+c;
}
// wird zu:
public static java.lang.String test(java.lang.String, java.lang.String, java.lang.String);
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
       7: aload_0
       8: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      11: aload_1
      12: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      15: aload_2
      16: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      19: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      22: areturn
}
//also quasi einfach alles appenden und einmal toString

wäre ja auch sonst ziemlich dumm vom Compiler unnötigerweise so viele zwischen Strings zu erzeugen^^

 

[Viktim]

Okay wieder schlauer geworden Danke

 

[stg]

Insgesamt dann also etwa so:

final String LNBREAK = "\r\n";

final int rows = model.getRowCount();
final int columns = model.getColumnCount();

StringBuilder sb = new StringBuilder();
for(int i = 0; i < rows; i++) {
    for(int j = 0; j < columns; j++) {
        String value = (String) model.getValueAt(i, j);
        if(value != null)
            sb.append('=').append('"').append(value).append('"');
        if(j < rows - 1)
            sb.append(';');
    }
    sb.append(LNBREAK);
}
String text = sb.toString();

Fällt einem noch was ein?

@Thallius Wie viel hat's denn nun tatsächlic gebracht?

 

[InfectedBytes]

wenn möglich schonmal die Kapazität so gut es geht angeben, damit möglichst selten ein größeres Array erzeugt werden muss.

StringBuilder sb = new StringBuilder(10000);

 

[stg]

wenn möglich schonmal die Kapazität so gut es geht angeben, damit möglichst selten ein größeres Array erzeugt werden muss.

Stimmt, hatte ich selbst ja sogar schon vorgeschlagen

 

[nvidia]

[....]

final String LNBREAK = "\r\n";

[...]

System.lineSeparator()

Davon abgesehen, es findet hier niemand unzweckmäßig jede Zeile einer Tabelle, mit der nichts besonderes gemacht wird, in einem langen String zu verketten um diesen dann in eine Datei zu schreiben? Würde man eine zusammengebastelte Zeile gleich an eine Einheit abgeben die sie in eine Datei schreibt benötigt man im besten Fall nur Speicher für ebendiese Zeile in String-Darstellung. Das Wegschreiben kann auch gerne asynchron laufen.

 

[Thallius]

Hi Leute,

sorry für die späte Antwort aber Meeting reiht sich gerade an Meeting

Also ich habe gar nicht erst groß mit dem Stringbuilder probiert sondern gleich, die natürlich viel schlauere Lösung, den Code so geändert, dass jede Zeile direkt ins File geschrieben wird. Das hatte ich ursprünglich auch eigentlich so gemacht, hatte es dann aber irgendwann aus mir nciht mehr unerfindlichen Gründen wieder geändert.

Nun läuft alles innerhalt 1 Sekunde ab.

Gruß

Claus