nicht angemeldet
Hallo,
Hallo,
Welche Vorteile bringen in diesem konkreten Fall StringBuffers gegenüber normalen Strings?
Im konkreten Fall gar nichts, weil der Compiler die String-Verkettung über
einen StringBuilder/StringBuffer realisiert.
Wenn man aber z.B. in einer Schleife immer weitere Strings an den String
anhängen möchte, sollte man tunlichst einen StringBuffer verwenden.
Für jede String-Verkettung erzeugt der Compiler nämlich einen neuen
StringBuffer.
Original:
String a = "abc";
String a = a + "def";
Kompilat:
String a = "abc";
StringBuffer buffer = new StringBuffer(a);
buffer.append("def");
a = buffer.toString();
Wie man sieht, wird ein neuer StringBuffer erzeugt. Dieser wird mit den
Daten in 'a' initialisiert. Dann wird "def" angehängt. Danach wird aus
dem StringBuffer wieder ein String erzeugt.
Hier werden also massig unnötige Objekte erzeugt. Steht das ganze in
einer Schleife, wird es noch schlimmer:
Original:
String a = "x";
for (int i = 0; i < 1000; i++) {
a = a + "x";
}
Kompilat:
String a = "x";
for (int i = 0; i < 1000; i++) {
StringBuffer buffer = new StringBuffer(a);
buffer.append("x");
a = buffer.toString();
}
Hier werden also 1000 unnötige StringBuffer-Objekte (und eigentlich auch
1000 unnötige String-Objekte) erzeugt.
Man sollte also bei einer solchen Schleife gleich wie folgt implementieren:
StringBuffer buffer = new StringBufer("x");
for (int i = 0; i < 1000; i++) {
buffer.append("x");
}
String a = buffer.toString();
Oder, weil wir ja wissen, daß genau 1001 'x' in den Buffer geschrieben
werden sollen, können wir die Größe des internen char-Arrays von StringBuffer
gleich auf 1001 initialisieren, damit nicht unnötigerweise während den
appends jeweils neue, größere interne char-Arrays angelegt werden müssen,
in die jeweils der Inhalt des vorherigen char-Arrays umkopiert werden muß.
Also:
StringBuffer buffer = new StringBufer(1001);
buffer.append("x");
for (int i = 0; i < 1000; i++) {
buffer.append("x");
}
String a = buffer.toString();
(Das doppelte 'append' hätte man natürlich durch das Erhöhen des
Schleifenzählers um 1 vermeiden können. Das soll jetzt aber nur zur
Veranschaulichung dienen...)
Wenn man mehrere String-Verkettungen direkt hintereinander macht, ist der
Compiler übrigens "schlau" genug, hier nur einen StringBuffer zu verwenden.
Original:
String a = "abc" + "def" + "ghi";
Kompilat:
StringBuffer buffer = new StringBuffer("abc");
buffer.append("def");
buffer.append("ghi");
String a = buffer.toString();
Aber das macht der Compiler halt wirklich nur in diesem speziellen Fall,
in dem die String-Verkettungen direkt (und fest) hintereinander erfolgen...
Gruß
Slyh