Unglaublich, aber heute hat mich Java zum zweiten Mal in meinem Leben enttäuscht:-(
Das erste Mal könnt ihr hier nachlesen. Wie die Überschrift des Blogeintrags verrät, geht es um Strings – genauer um die String Konkatenation. Je nachdem wie man Strings in Java miteinander verbindet, gibt es einen Performanceunterschied um den Faktor 100. Was ich herraus gefunden haben, könnt ihr hier lesen:
package main; public class Start { /** * @param args */ public static void main(String[] args) { // Zeit messen long start1 = System.currentTimeMillis(); String text = ""; for (int i = 0; i < 10000; i++) { // String konkatenieren text = text + "Hallo AxxG-Blog Leser! Wie geht es dir?"; } // Zeit messen long ende1 = System.currentTimeMillis(); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Zeit messen long start2 = System.currentTimeMillis(); StringBuilder strBuilder = new StringBuilder(); for (int i = 0; i < 10000; i++) { // String konkatenieren strBuilder.append("Hallo AxxG-Blog Leser! Wie geht es dir?"); } // Zeit messen long ende2 = System.currentTimeMillis(); // Diff System.out.println("String: " + (ende1 - start1 )); System.out.println("Builder: " + (ende2 - start2 )); } } [/java] <p>  <h2>Die Ausgabe</h2> [box type="shadow"] <h3>unter Windows XP (32 Bit)</h3> [text] String: 11625 Builder: 109 [/text] [/box] [box type="shadow"] <h3>unter Windows 7 (64 Bit)</h3> [text] String: 2389 Builder: 31 [/text] [/box] <p> </p> <h2>Fazit</h2> Mein Testprogramm zeigt, dass die <strong>String Konkatenation mit der Klasse StringBuilder 100 mal schneller geht</strong>, als die herkömmliche + Verkettung. Das liegt daran, dass Java intern die + Verkettung zu StringBuildern konvertiert. So wird aus: [java] String text = "Hallo " + "AxxG-Blog " + "Leser! ";
intern ein:
String text = new StringBuffer().append("Hallo ").append("AxxG-Blog ").append("Leser! ").toString();
Fügt man nun dem String „text“ weitere Zeichen hinzu, wird jedes mal ein neues StringBuilder-Objekt erzeugt! D.h. es muss jedes mal neuer Speicherplatz reserviert und der Inhalt komplett kopiert werden.
Guter Tipp! Danke 🙂
Hallo,
ich muss sagen, dass es zu den Grundlagen gehört. In jeder anderen Programmiersprach die ein StringBuilder-Konstrukt oder Methoden dafür bieten sollte man es auch verwenden.
Manchmal sind einem die banalsten Dinge nicht bekannt:-)
Und bei der heutigen Ausbildung auch nicht mehr zu erwarten….
Das liegt daran, dass ein String nicht änderbar ist. Die Klasse basiert intern auf einem Array, bei Konkatenation wird stets ein neues Array erzeugt 😉
Erstens der Code ist nicht vollständig richtig:
im ersten Fall hast du einen String erzeugt.
im zweiten Fall hast du KEINEN String sondern StringBuilder.
Also Statement strBuilder.toString() muss noch hinzugefügt werden.
Zweitens:
String (wie Andy richtig gesagt hat) ist nicht veränderbar also ist FINAL. Aber mit Array macht er Verwirrung.
Beim erzeugen eines Objekts also String wird in Heap einen Speicherplatz reserviert (Array von Chars), dieser ist nicht erweiterbar. Somit bei Concat-Notation hat man zwei String erzeugt und in Heap gelegt. Danach hat man eines Objekt in Heap der beide Strings erhält.
Aber StringBuilder arbeitet mit Zeigers (also wie ähnlich einen LinkedList aber NICHT). Hier spart man Speicher allocation on Heap level. Was recht aufwändig ist.