Java: Nutzt StringBuilder!

Zeitmessung in JavaUnglaublich, 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:

 

 

Das Test-Programm

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 ));	
	}
}

 

Die Ausgabe

unter Windows XP (32 Bit)

String: 11625
Builder: 109

unter Windows 7 (64 Bit)

String: 2389
Builder: 31

 

Fazit

Mein Testprogramm zeigt, dass die String Konkatenation mit der Klasse StringBuilder 100 mal schneller geht, als die herkömmliche + Verkettung. Das liegt daran, dass Java intern die + Verkettung zu StringBuildern konvertiert. So wird aus:

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.

 

MERKEN

Um diese Schritte einzusparen sollte man in Iterationen/Rekursionen/etc. immer StringBuilder(nicht Threadsafe, schneller) oder StringBuffer(Threadsafe, langsamer) einsetzen!

 

Quellen



5 Antworten : “Java: Nutzt StringBuilder!”

  1. PL07 sagt:

    Guter Tipp! Danke 🙂

  2. Bob sagt:

    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.

  3. Andy Stumpp sagt:

    Das liegt daran, dass ein String nicht änderbar ist. Die Klasse basiert intern auf einem Array, bei Konkatenation wird stets ein neues Array erzeugt 😉

  4. Alexander sagt:

    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.

Kommentar verfassen