nicht angemeldet
Hallo,
PS: Strings über den Plus-Operator zu verketten, ist böse. Besonders hier.
Oh, begründest Du das auch ein wenig? Ich verkette sie immer mit Plus wenn es nötig ist, eine Alternative habe ich ja gar nicht, oder?
Doch, hast du. StringBuffer und neuerdings auch StringBuilder.
Kurzer Hindergrund:
Wenn du String über + verkettest, wird mindestens ein String-Objekt
erzeugt, nämlich das, das den neuen String enthält, das aus den beiden
verketteten besteht.
Das ist bei einem einzelnen Aufruf auch völlig in Ordnung. Wenn man
aber mehrere Strings z.B. in einer Schleife verketten will, werden
hierfür sehr viele String-Objekte angelegt und vor allem auch deren
Inhalt ständig kopiert.
Beispiel:
Du hängst über eine Schleife zehnmal "abcdefg" an einen String an.
Beim ersten Durchlauf wird ein String mit 7 Zeichen erzeugt und
"abcdefg" hineinkopiert. Beim zweiten Durchlauf wird ein String-Objekt
mit 14 Zeichen erzeugt und das "abcdefg" aus dem letzten Durchgang
und noch einmal "abcdefg" hineinkopiert. Beim dritten Durchgang wird
wieder ein String-Objekt (21) erzeugt, in das "abcdefgabcdefg" und
dann "abcdefg" hineinkopiert wird. Beim 10. Durchgang wird ein String
mit 70 Zeichen erzeugt und zuerst der letzte String (9x"abcdefg") und
noch einmal "abcdefg" hineinkopiert.
Wie man sich leicht denken kann, verschwendet das Umkopieren eine
Menge Speicher und dauert auch eine nicht unerhebliche Zeit. Zudem
werden die String-Objekte von Durchlauf 1-9 nur kurzzeitig verwendet,
bleiben aber erstmal im Speicher stehen, bis der Gargabe Collector
sie abräumt.
Insgesamt ist String-Konkatenation über den Plus-Operator daher
eine schlechte Idee.
Wenn mehrere Strings zu einem großen String verknüpft werden sollen,
verwendet man StringBuffer. Dieses besteht intern aus einem char-Array
mit anfänglicher Größe, in das die anzuhängenden Werte einfach
reinkopiert werden können. Reicht der Platz im char-Array nicht aus,
wird es automatisch vergrößert.
Schau dir einfach mal die Klasse StringBuffer/StringBuilder an.
Außerdem ist in jedem Java-Buch der Nachteil von String-Verknüpfung
mit dem Plus-Operator dokumentiert und die Verwendung von
StringBuffer/StringBuilder erläutert.
Was kein Problem ist, ist Code wieder dieser:
String s1 = "abc";
String s2 = "def";
String s3 = "ghi";
String s4 = "jkl";
String s = s1 + s2 + s3 + s4;
Hier erzeugt der Java-Compiler beim Kompilieren automatisch ein
StringBuffer-Objekt und fügt die einzelnen Strings mit der append()-
Methode an.
Im obigen Beispiel (10x-Schleife) kann er dies nicht.
Gruß
Slyh
PS: Wenn ich noch richtig weiß, ist es sogar noch schlimmer als oben
beschrieben. Faktisch legt der Compiler nämlich bei jeder Operation
der Form "s1 + s2" zuerst ein StringBuffer-Objekt an, initialisiert
es mit dem Inhalt von s1, ruft dann append() mit s2 auf und konvertiert
den Inhalt anschließend über toString() wieder in einen String. Es
wird also zusätzlich zum eigentlich unnötigen String auch noch bei
jedem Schleifendurchlauf ein unnötiger StringBuffer erzeugt.
seth