aus Sicht der Performance ist es besser einen “zu großen” StringBuilder anzulegen, da später kein aufwendiges Arrays.copyOf() statt finden muss. Aus Sicht der Ressourcen belegt ein StringBuilder dann aber auch sofort ein char Array der entsprechenden Initialgröße (hier 255). Dies ist aber vernachlässigbar.

Im Code zu AbstractStringBuilder kann man sich den Konstruktor auch anschauen:

char value[];
...

AbstractStringBuilder(int capacity) {
  value = new char[capacity];
}

Gruß
Sebastian

völlig egal ist es nicht. Wie am obigen Beispiel gesehen werden kann, würde der Compiler aus dem hier:

String str = "Simpler";
str += " String";

das hier machen

String s = "Simpler";
s = (new StringBuilder()).append(s).append(" String").toString();

Noch performanter wäre es natürlich, wenn man von Anfang an das hier schreiben würde

StringBuilder s = new StringBuilder("Simpler");
s.append(" String");

Aber bei so etwas würde ich die Lesbarkeit (die bei der Verwendung von String deutlich höher sein sollte) über den minimalen Performancevorteil stellen.

Um die zweite Frage zu beantworte, werfen wir am Besten einen Blick in den Java Sourcecode. Was passiert, wenn ein weiterer String an den StringBuilder via append angehängt wird? Die Lösung befindet sich im Sourcecode der Klasse AbstractStringBuilder von welcher der StringBuilder abgeleitet ist.

public AbstractStringBuilder append(String str) {
  if (str == null) str = "null";
  int len = str.length();
  if (len == 0) return this;
  int newCount = count + len;
  if (newCount > value.length)
    expandCapacity(newCount);
  str.getChars(0, len, value, count);
  count = newCount;
  return this;
}

Für die Frage ist nur die Zeile

if (newCount > value.length)
  expandCapacity(newCount);

relevant. Was paassiert, wenn die neue Größe des StringBuilders die Alte übersteigt?

void expandCapacity(int minimumCapacity) {
  int newCapacity = (value.length + 1) * 2;
  if (newCapacity < 0) {
    newCapacity = Integer.MAX_VALUE;
  } else if (minimumCapacity > newCapacity) {
    newCapacity = minimumCapacity;
  }
  value = Arrays.copyOf(value, newCapacity);
}

Die Kapazität wird um das Doppelte erhöht. Wird der Wertebereich des Integers überschritten, ist die neue Kapazität gleich der maximalen Größe eines Integers. Außerdem wird noch überprüft, ob die Verdoppelung der Kapazität für die neue Größe ausreicht. Ist dies nicht der Fall, wird die aktuelle Größe gleich der neuen Größe gesetzt. Abschließend wird das alte Array, welches den Inhalt des StringBuilders beinhaltet, in ein neues, an die neue Größe angepasstes, Array kopiert.

Der "+16"-Mythos resultiert daraus, dass beim Anlegen eines neuen StringBuilders automatisch die Kapazität auf "Länge des Initial-Strings" + 16 gesetzt wird.

Dennoch ist es optimal, die ungefähre Kapazität des StringBuilders im Voraus abzuschätzen - sofern möglich.

Ich hoffe ich konnte helfen. Ansonsten einfach noch einmal nachfragen.

Gruß
Stefan

ich hätte da mal eine kleine Frage. Also d.h. außerhalb einer Schleife ist ein StringBuilder egal wieviel Strings ich aneinanderreihe total überflüßig(außer ich benötige die Methoden)?

Ist es nicht so wenn ich den default StringBuilder () benutze er nach 16 zeichen einen neuen String erzeugt und diesen dann einfügen muss. Darum sollte doch vorher abgeschätzt werden wie groß der Builder werden kann , sonst ist der Vorteil geringer?z.B. new StringBuilder(255);

Ich freu mich auf Ihre Antwort !!!

Gruß Marc

vielen Dank für die Anmerkung. Ich werde das Kapitel sofort ergänzen.

Gruß
Stefan

ein kleiner Verbesserungsvorschlag, ich finde man könnte bei den Vergleichen noch erwähnen, dass wenn man 2 unterschiedliche Instanzen von StringBuilder/StringBuffer vergleicht auch false rauskommt !!obowhl!! gleichen Inhaltes.

        StringBuilder builder = new StringBuilder("123");
        StringBuilder builder2 = new StringBuilder("123");

        if(builder.equals(builder2)) // false