Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 13 Dateien und Datenströme
|  | 13.1 Datei und Verzeichnis
|  |  | 13.1.1 Dateien und Verzeichnisse mit der Klasse File
|  |  | 13.1.2 Verzeichnis oder Datei? Existiert es?
|  |  | 13.1.3 Verzeichnis- und Dateieigenschaften/-attribute
|  |  | 13.1.4 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher
|  |  | 13.1.5 Umbenennen und Verzeichnisse anlegen
|  |  | 13.1.6 Verzeichnisse listen und Dateien filtern
|  |  | 13.1.7 Dateien berühren, neue Dateien anlegen, temporäre Dateien
|  |  | 13.1.8 Dateien und Verzeichnisse löschen
|  |  | 13.1.9 Verzeichnisse nach Dateien iterativ durchsuchen
|  |  | 13.1.10 URL- und URI-Objekte aus einem File-Objekt ableiten
|  |  | 13.1.11 Mit Locking Dateien sperren
|  |  | 13.1.12 Sicherheitsprüfung
|  |  | 13.1.13 Mime-Typen mit dem JavaBeans Activation Framework (JAF)
|  |  | 13.1.14 Zugriff auf SMB-Server mit jCIFS
|  | 13.2 Dateien mit wahlfreiem Zugriff
|  |  | 13.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen
|  |  | 13.2.2 Aus dem RandomAccessFile lesen
|  |  | 13.2.3 Schreiben mit RandomAccessFile
|  |  | 13.2.4 Die Länge des RandomAccessFile
|  |  | 13.2.5 Hin und her in der Datei
|  |  | 13.2.6 Wahlfreier Zugriff und Pufferung mit Unified I/O
|  | 13.3 Stream-Klassen und Reader/Writer am Beispiel von Dateien
|  |  | 13.3.1 Mit dem FileWriter Texte in Dateien schreiben
|  |  | 13.3.2 Zeichen mit der Klasse FileReader lesen
|  |  | 13.3.3 Kopieren mit FileOutputStream und FileInputStream
|  |  | 13.3.4 Das FileDescriptor-Objekt
|  | 13.4 Basisklassen für die Ein-/Ausgabe
|  |  | 13.4.1 Die abstrakten Basisklassen
|  |  | 13.4.2 Übersicht über Ein-/Ausgabeklassen
|  |  | 13.4.3 Die abstrakte Basisklasse OutputStream
|  |  | 13.4.4 Die Schnittstellen Closeable und Flushable
|  |  | 13.4.5 Ein Datenschlucker
|  |  | 13.4.6 Die abstrakte Basisklasse InputStream
|  |  | 13.4.7 Ressourcen wie Grafiken aus dem Klassenpfad und aus Jar–Archiven laden
|  |  | 13.4.8 Ströme mit SequenceInputStream zusammensetzen
|  |  | 13.4.9 Die abstrakte Basisklasse Writer
|  |  | 13.4.10 Die Schnittstelle Appendable
|  |  | 13.4.11 Die abstrakte Basisklasse Reader
|  | 13.5 Formatierte Textausgaben
|  |  | 13.5.1 Die Klassen PrintWriter und PrintStream
|  |  | 13.5.2 System.out, System.err und System.in
|  |  | 13.5.3 Geschützte Passwort-Eingaben mit der Klasse Console
|  | 13.6 Schreiben und Lesen aus Strings und Byte-Feldern
|  |  | 13.6.1 Mit dem StringWriter ein String-Objekt füllen
|  |  | 13.6.2 CharArrayWriter
|  |  | 13.6.3 StringReader und CharArrayReader
|  |  | 13.6.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben
|  |  | 13.6.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen
|  | 13.7 Datenströme filtern und verketten
|  |  | 13.7.1 Streams als Filter verketten
|  |  | 13.7.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream
|  |  | 13.7.3 Gepufferte Eingaben mit BufferedReader und BufferedInputStream
|  |  | 13.7.4 LineNumberReader zählt automatisch Zeilen mit
|  |  | 13.7.5 Daten mit der Klasse PushbackReader zurücklegen
|  |  | 13.7.6 DataOutputStream/DataInputStream
|  |  | 13.7.7 Basisklassen für Filter
|  |  | 13.7.8 Die Basisklasse FilterWriter
|  |  | 13.7.9 Ein LowerCaseWriter
|  |  | 13.7.10 Eingaben mit der Klasse FilterReader filtern
|  | 13.8 Vermittler zwischen Byte-Streams und Unicode-Strömen
|  |  | 13.8.1 Datenkonvertierung durch den OutputStreamWriter
|  |  | 13.8.2 Automatische Konvertierungen mit dem InputStreamReader
|  | 13.9 Kommunikation zwischen Threads mit Pipes
|  |  | 13.9.1 PipedOutputStream und PipedInputStream
|  |  | 13.9.2 PipedWriter und PipedReader
|  | 13.10 Datenkompression
|  |  | 13.10.1 Java-Unterstützung beim Komprimieren und Zusammenpacken
|  |  | 13.10.2 Datenströme komprimieren
|  |  | 13.10.3 Zip-Archive
|  |  | 13.10.4 Jar-Archive
|  | 13.11 Prüfsummen
|  |  | 13.11.1 Die Schnittstelle Checksum
|  |  | 13.11.2 Die Klasse CRC32
|  |  | 13.11.3 Die Adler32-Klasse
|  | 13.12 Persistente Objekte und Serialisierung
|  |  | 13.12.1 Objekte mit der Standard-Serialisierung speichern und lesen
|  |  | 13.12.2 Zwei einfache Anwendungen der Serialisierung
|  |  | 13.12.3 Die Schnittstelle Serializable
|  |  | 13.12.4 Nicht serialisierbare Attribute aussparen
|  |  | 13.12.5 Das Abspeichern selbst in die Hand nehmen
|  |  | 13.12.6 Tiefe Objektkopien
|  |  | 13.12.7 Versionenverwaltung und die SUID
|  |  | 13.12.8 Wie die ArrayList serialisiert
|  |  | 13.12.9 Probleme mit der Serialisierung
|  |  | 13.12.10 Serialisieren in XML-Dateien
|  |  | 13.12.11 JavaBeans Persistence
|  |  | 13.12.12 XStream
|  | 13.13 Tokenizer
|  |  | 13.13.1 StreamTokenizer
|  |  | 13.13.2 CSV-(Comma Separated Values-)Dateien verarbeiten
|  | 13.14 Zum Weiterlesen
## 13.6 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. Hier klicken, um das Bild zu vergrößern ### 13.6.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 13.23 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 (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 immer der zweite Konstruktor aus Effizienzgründen Verwendung finden. So muss sich das interne StringBuffer-Objekt bei wiederholten write()-Aufrufen nicht immer in der Größe ändern. Mit den Funktionen 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
    extends Writer
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. ### 13.6.2 CharArrayWriter Neben StringWriter schreibt auch die Klasse CharArrayWriter Zeichen in einen Puffer, doch diesmal in ein Zeichenfeld. Sie bietet zudem drei zusätzliche Funktionen an: reset(), size() und writeTo().
    class java.io.CharArrayWriter
    extends Writer
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 geben der Writer vor. close() und flush() sind wie beim StringWriter leer. ### 13.6.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. Hier klicken, um das Bild zu vergrößern Listing 13.24 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
    extends Reader
StringReader( String s ) Erzeugt einen neuen StringReader, der die Zeichen aus dem String s liest.
    class java.io.CharArrayReader
    extends Reader
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 der angegebenen Verschiebung. Die Klassen StringReader und CharArrayReader überschreiben die Funktionen 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.
Hier klicken, um das Bild zu vergrößern ### 13.6.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 13.25 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
    extends OutputStream
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), dass das für uns nicht sichtbare interne Feld buf schreibt. ### 13.6.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
    extends InputStream
ByteArrayInputStream( byte[] buf ) Erzeugt ein neues InputStream-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.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de