6.4 Schreiben und Lesen aus Strings und Byte-Feldern
Zwei interessante Writer sind StringWriter und CharArrayWriter, weil sie die Ausgabe nicht in eine Datei, sondern in einen StringBuffer beziehungsweise in ein Zeichen-Array schreiben. Die Felder werden automatisch vergrößert. Für Byte-Felder sind ByteArrayOutputStream und ByteArrayInputStream relevant. Die Klassen lassen sich exzellent für Testfälle nutzen, denn für eine Methode, die zum Beispiel in einen beliebigen Writer schreibt, ist es egal, ob sie zum Testen in einen StringWriter oder produktiv in einen FileWriter schreibt.
Abbildung 6.4: UML-Diagram der Klassen StringWriter und CharArrayWriter
6.4.1 Mit dem StringWriter ein String-Objekt füllen
Die folgenden Programmzeilen werten einen StringWriter noch zu einem PrintWriter auf, damit wir die komfortablen printXXX()-Methoden verwenden können:
Listing 6.10: com/tutego/insel/io/stream/StringWriterDemo.java, main()
StringWriter buffer = new StringWriter();
PrintWriter out = new PrintWriter( buffer );
out.print( "Christian" );
out.printf( "ist lieb.%n" );
out.println();
String result = buffer.toString();
System.out.println( result ); // Christian ist lieb.\n\n
Der parameterlose Konstruktor new StringWriter() legt einen internen Puffer mit der Größe 16 an (der Standardgröße eines StringBuffer-Objekts). Daneben existiert aber noch ein Konstruktor mit dem Parameter int, der die anfängliche Größe festsetzt. Ist die Zeichenkette, die der StringWriter später aufnimmt, auf jeden Fall größer als 16, sollte aus Effizienzgründen immer der zweite Konstruktor Verwendung finden. So muss sich das interne StringBuffer-Objekt bei wiederholten write()-Aufrufen nicht immer in der Größe ändern.
Mit den Methoden getBuffer() und toString() lesen wir den Inhalt wieder aus. Die Methoden unterscheiden sich darin, dass getBuffer() ein StringBuffer-Objekt zurückgibt und toString() das gewohnte String-Objekt.
class java.io.StringWriter |
- StringWriter()
Erzeugt einen StringWriter mit der Startgröße 16. - StringWriter(int initialSize)
Erzeugt einen StringWriter mit der angegebenen Größe. - StringBuffer getBuffer()
Liefert den internen StringBuffer, keine Kopie. - String toString()
Liefert den Puffer als String.
Die write()- bzw. append()-Methoden aus dem Writer sind so wie erwartet. close() ist leer implementiert, und so lassen sich auch nach dem Schließen Zeichen schreiben. Ebenso ist flush() leer implementiert.
6.4.2 CharArrayWriter
Neben StringWriter schreibt auch die Klasse CharArrayWriter Zeichen in einen Puffer, doch diesmal in ein Zeichenfeld. Sie bietet zudem drei zusätzliche Methoden an: reset(), size() und writeTo().
class java.io.CharArrayWriter |
- CharArrayWriter()
Erzeugt einen neuen CharArrayWriter mit einer Standardgröße. - CharArrayWriter(int initialSize)
Erzeugt einen neuen CharArrayWriter mit einer Startkapazität von initialSize Zeichen. - void writeTo(Writer out)
Schreibt den Inhalt des Puffers in einen anderen Zeichenstrom. Diese Methode ist recht nützlich, um die Daten weiterzugeben. - void reset()
Setzt den internen Puffer zurück, sodass das CharArrayWriter-Objekt ohne neue Speicheranforderung genutzt werden kann. - int size()
Liefert die Größe des Puffers. - char[] toCharArray()
Gibt eine Kopie der Eingabedaten zurück. Es ist wirklich eine Kopie und keine Referenz. - String toString()
Konvertiert die Eingabedaten in einen String.
Die write()- und append()-Methoden gibt der Writer vor. close() und flush() sind wie beim StringWriter leer.
6.4.3 StringReader und CharArrayReader
Die Klassen StringWriter und CharArrayWriter haben die entsprechenden Lese-Klassen mit den Namen StringReader und CharArrayReader. Beide erlauben das Lesen von Zeichen aus einem String beziehungsweise aus einem Zeichenfeld. Sie leiten sich beide direkt aus Writer ab.
Abbildung 6.5: UML-Diagramm der Klassen StringReader und CharArrayReader
Listing 6.11: com/tutego/insel/io/stream/StringReaderDemo.java, main()
String s = "Hölle Hölle Hölle";
Reader sr = new StringReader( s );
char H = (char) sr.read();
char ö = (char) sr.read();
for ( int c; (c = sr.read()) != –1; )
System.out.print( (char) c );
class java.io.StringReader |
- StringReader(String s )
Erzeugt einen neuen StringReader, der die Zeichen aus dem String s liest.
class java.io.CharArrayReader |
- CharArrayReader(char[] buf)
Erzeugt einen CharArrayReader vom angegebenen Feld. - CharArrayReader(char[] buf, int offset, int length)
Erzeugt einen CharArrayReader vom angegebenen Feld der Länge length und mit der angegebenen Verschiebung.
Die Klassen StringReader und CharArrayReader überschreiben die Methoden close(), mark(int), markSupported(), read(), read(char[] cbuf, int off, int len), ready(), reset() und skip(long). Sie unterstützen skip(), mark() und reset().
| Hinweis |
|
Das Zeichenfeld, das CharArrayReader erhält, wird intern nicht kopiert, sondern referenziert. Das heißt, dass nachträgliche Änderungen am Feld die aus dem Stream gelesenen Zeichen beeinflussen. |
Abbildung 6.6: Vererbungsbeziehung StringReader und Reader
6.4.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben
Die Klasse ByteArrayOutputStream lässt sich gut verwenden, wenn mehrere unterschiedliche primitive Datentypen in ein Byte-Feld kopiert werden sollen, die dann später eventuell binär weiterkodiert werden müssen. Erstellen wir etwa eine GIF-Datei, müssen wir nacheinander verschiedene Angaben schreiben. So erstellen wir leicht eine Grafikdatei im Speicher. Anschließend konvertieren wir mit toByteArray() den Inhalt des Datenstroms in ein Byte-Feld:
Listing 6.12: com/tutego/insel/io/stream/ByteArrayOutputStreamDemo.java, main()
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream( baos );
// Header
out.write( 'G' ); out.write( 'I' ); out.write( 'F' );
out.write( '8' ); out.write( '9' ); out.write( 'a' );
// Logical Screen Descriptor
out.writeShort( 128 ); // Logical Screen Width (Unsigned)
out.writeShort( 37 ); // Logical Screen Height (Unsigned)
// <Packed Fields>, Background Color Index, Pixel Aspect Ratio
// and so on.
out.close();
byte[] result = baos.toByteArray();
class java.io.ByteArrayOutputStream |
- ByteArrayOutputStream()
Erzeugt ein neues OutputStream-Objekt, das die Daten in einem Byte-Feld abbildet. - ByteArrayOutputStream(int size)
Erzeugt ein ByteArrayOutputStream mit einer gewünschten Pufferkapazität.
Mit die wichtigste Methode ist toByteArray(), die ein byte[] mit dem geschriebenen Inhalt liefert. reset() löscht den internen Puffer. Eine praktische Methode ist writeTo(OutputStream out). Hinter ihr steckt ein out.write(buf, 0, count), das das für uns nicht sichtbare interne Feld buf schreibt.
6.4.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen
Ein ByteArrayInputStream ist ein besonderer InputStream, der aus Byte-Feldern liest. Die Quelle der Daten, das Byte-Feld, wird im Konstruktor übergeben und intern nicht kopiert.
class java.io.ByteArrayInputStream |
- ByteArrayInputStream(byte[] buf)
Erzeugt ein neues ByteArrayInputStream-Objekt, das alle Daten aus dem Byte-Feld buf liest. - ByteArrayInputStream(byte[] buf, int offset, int length)
Erzeugt ByteArrayInputStream, das einem Teil des Feldes Daten entnimmt.
Ihr Kommentar
Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
