4.4 Veränderbare Zeichenketten mit StringBuilder/StringBuffer

Zeichenketten, die in der virtuellen Maschine in String-Objekten gespeichert sind, haben die Eigenschaft, dass ihr Inhalt nicht mehr verändert werden kann. Anders verhalten sich die Exemplare der Klasse StringBuilder und StringBuffer, an denen sich Veränderungen vornehmen lassen. Die Veränderungen betreffen anschließend das StringBuilder-/StringBuffer-Objekt selbst, und es wird kein neu erzeugtes Objekt als Ergebnis geliefert, wie zum Beispiel beim Plus-Operator und der concat()-Methode bei herkömmlichen String-Objekten. Sonst sind sich aber die Implementierung von String-Objekten und StringBuffer-/StringBuffer-Objekten ähnlich. In beiden Fällen nutzen die Klassen ein internes Zeichenfeld.

Die Klasse StringBuilder bietet die gleichen Methoden wie StringBuffer, nur nicht synchronisiert. Bei nebenläufigen Programmen kann daher die interne Datenstruktur vom StringBuilder-Objekt inkonsistent werden, ist aber dafür bei nicht-nebenläufigen Zugriffen ein wenig schneller.

4.4.1 Anlegen von StringBuilder-/StringBuffer-Objekten

Mit mehreren Konstruktoren lassen sich StringBuilder-/StringBuffer-Objekte generieren.

final class java.lang.StringBuffer 
final class java.lang.StringBuilder 
implements Appendable, CharSequence, Serializable

• StringBuffer(), StringBuilder()
  Legt ein neues Objekt an, das die leere Zeichenreihe enthält und Platz für (zunächst) bis zu 16 Zeichen bietet. Bei Bedarf wird automatisch Platz für weitere Zeichen bereitgestellt.

• StringBuffer( int length ), StringBuilder( int length )
  Wie oben, jedoch reicht die anfängliche Kapazität des Objekts für die angegebene Anzahl an Zeichen. Optimalerweise ist die Größe so zu setzen, dass sie der Endgröße der dynamischen Zeichenfolge nahekommt.

• StringBuffer( String str ), StringBuilder( String str )
  Baut ein Objekt, das eine Kopie der Zeichen aus str enthält. Zusätzlich wird bereits Platz für 16 weitere Zeichen eingeplant.

• StringBuffer( CharSequence seq ), StringBuilder( CharSequence seq )
  Erzeugt ein neues Objekt aus einer CharSequence. Damit können auch die Zeichenfolgen anderer StringBuffer- und StringBuilder-Objekte Basis dieses Objekts werden.

Da nur String-Objekte von der Sprache bevorzugt werden, bleibt uns allein der explizite Aufruf eines Konstruktors, um StringBuilder-/StringBuffer-Exemplare anzulegen. Alle String-Literale in Anführungszeichen sind ja schon Exemplare der Klasse String.

4.4.2 Die Länge eines StringBuilder-/StringBuffer-Objekts

Wie bei einem String lässt sich die Länge und die Anzahl der enthaltenen Zeichen mit der Methode length() erfragen. StringBuilder-/StringBuffer-Objekte haben jedoch auch eine interne Puffergröße, die sich mit capacity() erfragen lässt und im Konstruktor wie beschrieben festgelegt wird. In diesem Puffer, der genauer gesagt ein Array vom Typ char ist, werden die Veränderungen wie das Ausschneiden oder Anhängen von Zeichen vorgenommen. Während length() die Anzahl der Zeichen angibt, ist capacity() immer größer oder gleich length() und sagt etwas darüber aus, wie viele Zeichen der Puffer noch aufnehmen kann, ohne dass intern ein neues, größeres Feld benötigt würde.

StringBuilder sb = new StringBuilder( "www.tutego.com" ); 
System.out.println( sb.length() );                           // 14 
System.out.println( sb.capacity() );                         // 30

Die Startgröße sollte mit der erwarteten Größe initialisiert werden, um späteres teures internes Vergrößern zu vermeiden. Falls der StringBuilder/StringBuffer einen großen internen Puffer hat, aber auf lange Sicht nur wenig Zeichen besitzt, lässt er sich mit trimToSize() auf eine kleinere Größe schrumpfen.

Ändern der Länge

Soll der StringBuilder/StringBuffer mehr Daten aufnehmen, so ändert setLength() die Länge auf eine angegebene Anzahl von Zeichen. Der Parameter ist die neue Länge. Ist sie kleiner als length(), so wird der Rest der Zeichenkette einfach abgeschnitten. Die Größe des internen Puffers ändert sich dadurch nicht. Ist setLength() größer, so vergrößert sich der Puffer, und die Methode füllt die übrigen Zeichen mit Nullzeichen '\0000' auf. Die Methode ensureCapacity() fordert, dass der interne Puffer für eine bestimmte Anzahl von Zeichen ausreicht. Wenn nötig, legt sie ein neues, vergrößertes char-Array an, verändert aber nicht die Zeichenfolge, die durch das StringBuilder-/StringBuffer-Objekt repräsentiert wird.

4.4.3 Daten anhängen

Die häufigste Anwendung von StringBuilder-/StringBuffer-Objekten ist das Zusammenfügen von Texten aus Daten unterschiedlichen Typs. Dazu deklarieren die Klassen eine Reihe von append()-Methoden, die mit unterschiedlichen Datentypen überladen sind. Die append()-Methoden von StringBuilder geben einen StringBuilder zurück und die von StringBuffer einen StringBuffer.

• StringBuffer/StringBuilder append( boolean b )

• StringBuffer/StringBuilder append( char c )

• StringBuffer/StringBuilder append( char[] str )

• StringBuffer/StringBuilder append( char[] str, int offset, int len )

• StringBuffer/StringBuilder append( CharSequence s )

• StringBuffer/StringBuilder append( CharSequence s, int start, int end )

• StringBuffer/StringBuilder append( double d )

• StringBuffer/StringBuilder append( float f )

• StringBuffer/StringBuilder append( int i )

• StringBuffer/StringBuilder append( long lng )

• StringBuffer/StringBuilder append( Object obj )

• StringBuffer/StringBuilder append( String str )

• StringBuffer/StringBuilder append( StringBuffer sb )

Drei der Methoden – mit den Argumenten (char), (CharSequence), (CharSequence, int, int) – werden von der Schnittstelle Appendable vorgeschrieben.

Besonders nützlich ist in der Praxis append(CharSequence, int, int), da sich auf diese Weise Teile von String-, StringBuilder- und StringBuffer-Objekten anhängen lassen. Die append()-Methoden hängen immer an das Ende an und vergrößern den internen Platz – das interne char-Feld –, falls es nötig ist. Ein neues StringBuilder-/StringBuffer-Objekt erzeugen sie nicht.

StringBuilder sb = new StringBuilder( "George Peppard " ).append(','); 
sb.append(" Mr. T, ").append("Dirk Benedict, ").append("Dwight Schultz");

4.4.4 Zeichen(folgen) setzen, erfragen, löschen und umdrehen

Die bekannten Anfragemethoden aus String finden wir auch beim StringBuilder/StringBuffer wieder. So verhalten sich charAt() und getChars() bei Exemplaren beider Klassen identisch. Auch substring(int start) und substring(int start, int end) sind aus der Klasse String bekannt.

Neu ist setCharAt(), da in einem StringBuilder/StringBuffer Zeichen verändert werden können.

StringBuilder sb = new StringBuilder("spare Wasser und dusche mit der Freundin"); 
char upperCharacter = Character.toUpperCase( sb.charAt(0) ); 
sb.setCharAt( 0, upperCharacter );

Eine Folge von Zeichen lässt sich durch delete(int start, int end) löschen. deleteChar-At(int index) löscht nur ein Zeichen. In beiden Fällen wird ein inkorrekter Index durch eine StringIndexOutOfBoundsException bestraft. Die Methode replace(int start, int end, String str) löscht zuerst die Zeichen zwischen start und end und fügt anschließend den neuen String str ab start ein. Dabei sind die Endpositionen wie immer exklusiv, das heißt, sie geben das erste Zeichen hinter dem zu verändernden Ausschnitt an. Die Methode insert(int offset, Typ) fügt die Zeichenketten-Repräsentation eines Werts vom Typ Typ an die Stelle offset ein. Sie ähnelt der überladenen append()-Methode. Für char-Arrays existiert insert() in einer abgewandelten Art: insert(int index, char[] str, int offset, int len). Es wird nicht das komplette Array in den StringBuilder/StringBuffer übernommen, sondern nur ein Ausschnitt.

StringBuilder sb = new StringBuilder( "SubEtha-Sens-O-Matic" ); 
char val = '-'; 
sb.insert( 3, val );                       // Sub-Etha-Sens-O-Matic

Eine weitere Methode reverse() dreht die Zeichenfolge um.

boolean isPalindrome = new StringBuilder(s).reverse().toString().equalsIgnoreCase(s);

4.4.5 Vergleichen von String/StringBuilder/StringBuffer

Zum Vergleichen von Zeichenketten bietet sich die bekannte equals()-Methode an. Diese ist aber bei StringBuilder/StringBuffer nicht wie erwartet implementiert. Dazu gesellen sich andere Methoden, die zum Beispiel unabhängig von der Groß-/Kleinschreibung vergleichen.

equals() bei der String-Klasse

Ein Blick in die API-Dokumentation der Klasse String zeigt die bekannte equals(Object)-Methode. Zwar erlaubt der Parametertyp durch den Basistyp Object beliebige Objekte (also etwa Point, String, Date, StringBuilder), doch das equals() von String vergleicht nur String/String-Paare. Die Methode beginnt erst dann den Vergleich, wenn das Argument auch vom Typ String ist. Das testet die Methode mit dem speziellen Operator instanceof. Das bedeutet, dass der Compiler mit dem Argumenttyp StringBuilder/StringBuffer bei equals() kein Problem hat, doch zur Laufzeit ist das Ergebnis immer false, da eben ein StringBuilder/StringBuffer nicht instanceof String ist. Ob die Zeichenfolgen dabei gleich sind, spielt keine Rolle.

Eine Lösung für den Vergleich String mit StringBuilder/StringBuffer ist, zunächst mit toString() den StringBuilder/StringBuffer in einen String zu überführen und dann die beiden Strings mit equals() zu vergleichen.

contentEquals() beim String

Eine allgemeine Methode zum Vergleich eines Strings mit entweder einem anderen String oder mit StringBuilder/StringBuffer ist contentEquals(CharSequence). Die Methode liefert die Rückgabe true, wenn der String und die CharSequence (String, StringBuilder/StringBuffer sind Klassen vom Typ CharSequence) den gleichen Zeicheninhalt haben. Die interne Länge des Puffers spielt keine Rolle. Ist das Argument null, wird eine NullPointerException ausgelöst.

String s = "Elektrisch-Zahnbürster"; 
StringBuffer sb = new StringBuffer( "Elektrisch-Zahnbürster" ); 
System.out.println( s.equals(sb) );                   // false 
System.out.println( s.equals(sb.toString()) );        // true 
System.out.println( s.contentEquals(sb) );            // true

equals() bei StringBuffer bzw. StringBuilder?

Wollen wir zwei StringBuffer- bzw. StringBuilder-Objekte miteinander vergleichen, werden wir noch mehr enttäuscht: Die Klassen deklarieren überhaupt keine eigene equals()-Methode. Es gibt zwar die übliche von Object geerbte Methode, doch das heißt, nur Objektreferenzen werden verglichen. Wenn also zwei verschiedene StringBuffer/StringBuilder-Objekte mit gleichem Inhalt mit equals() verglichen werden, kommt trotzdem immer false heraus.

StringBuilder sb1 = new StringBuilder( "www.tutego.com" ); 
StringBuilder sb2 = new StringBuilder( "www.tutego.com" ); 
System.out.println( sb1.equals( sb2 ) );                        // false 
System.out.println( sb1.toString().equals( sb2.toString() ) );  // true 
System.out.println( sb1.toString().contentEquals( sb2 ) );      // true

4.4.6 hashCode() bei StringBuffer/StringBuilder

Die obige Betrachtung zeigt, dass eine Methode equals(), die den Inhalt von StringBuilder-/StringBuffer-Objekten vergleicht, nicht schlecht wäre. Dennoch besteht das Problem, wann StringBuilder-/StringBuffer-Objekte als gleich angesehen werden sollen. Das ist interessant, denn StringBuilder-/StringBuffer-Objekte sind nicht nur durch ihren Inhalt bestimmt, sondern auch durch die Größe ihres internen Puffers, ihre Kapazität. Sollte equals() den Rückgabewert true haben, wenn die Inhalte gleich sind, oder nur, wenn Inhalt und Puffergröße gleich sind? Da jeder Entwickler andere Ansichten über die Gleichheit besitzt, bleibt es bei dem standardmäßigen Test auf identische Objektreferenzen.

Eine ähnliche Argumentation gilt bei der hashCode()-Methode, die für alle inhaltsgleichen Objekte denselben, im Idealfall eindeutigen Zahlenwert liefert. Die Klasse String besitzt eine hashCode()-Methode, doch StringBuffer/StringBuilder erbt die Implementierung aus der Klasse Object unverändert. Mit anderen Worten: Die Klassen selbst bieten keine Implementierung an.

Ihr Kommentar