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.9 Kommunikation zwischen Threads mit Pipes Die Kommunikation zwischen Programmteilen kann auf vielfältige Weise geschehen. Einige Möglichkeiten haben wir bei Threads kennengelernt. Bei getrennten Programmen lässt sich die Kommunikation über Dateien realisieren. Auch Datenströme können von einem Teil geschrieben und vom anderen gelesen werden. Wenn wir aber mit Threads arbeiten, wäre eine Kommunikation über Dateien zwar denkbar, aber zu aufwändig. Ein anderes Stromkonzept ist praktisch. ### 13.9.1 PipedOutputStream und PipedInputStream Einfacher ist der Austausch der Daten über eine so genannte Pipe. Sie wird gebildet über Paare spezieller Stromklassen PipedOutputStream/PipedInputStream beziehungsweise PipedWriter/PipedReader, übliche Unterklassen von OutputStream/InputStream und Writer/Reader. (Wir verfolgen im nächsten Beispiel die Byte-Variante.) Wenn dann Threads Daten austauschen wollen, kann ein Produzent sie über write() in den Ausgabestrom schreiben, und der andere Thread wird sie dort über read() empfangen können. Natürlich muss ein schreibender Pipe-Strom wissen, wer der Empfänger ist. Daher müssen die Schreib-/Lese-Pipes miteinander verbunden werden. Eine Möglichkeit bietet connect().
Beispiel Ein PipedOutputStream soll mit einem PipedInputStream verbunden werden.
    PipedOutputStream pos = new PipedOutputStream();
    PipedInputStream  pis = new PipedInputStream();
    pos.connect( pis );
    // oder pis.connect( pos );
Werden jetzt Daten produziert und in den pos geschrieben, kommen sie über den pis wieder an und können dort konsumiert werden.
Ob wir nun vom PipedOutputStream die Methode connect(PipedInputStream) nehmen oder vom PipedInputStream die Methode connect(PipedOutputStream), ist dabei egal. Statt nach dem Aufbau der Ströme über den Standardkonstruktor beide mit connect() zu verbinden, gibt es eine alternative Lösung. Entweder lässt sich nach dem Erzeugen des PipedOutputStream über den Standardkonstruktor das frische Strom-Objekt in den parametrisierten Konstruktor von PipedInputStream übergeben oder eben umgekehrt ein neues PipedInputStream-Objekt in den parametrisierten Konstruktor von PipedOutputStream legen. Hier klicken, um das Bild zu vergrößern
Beispiel Verbinde den Eingabe-Stream pis mit dem Ausgabe-Stream pos:
    PipedInputStream  pis = new PipedInputStream();
    PipedOutputStream pos = new PipedOutputStream( pis );
#### Interna Der Austausch der Daten geschieht über einen internen Puffer, den PipedInputStream anlegt. Die Daten, die PipedOutputStream über write() schreiben soll, gelangen direkt zum Puffer des Eingabestroms. Werfen wir einen kurzen Blick auf die relevanten Teile der Implementierung:
    class PipedOutputStream extends OutputStream
    {
       private PipedInputStream sink;

       public PipedOutputStream( PipedInputStream snk )
          throws IOException
       {
        /* Auskommentierte Fehlerbehandlung */
        sink = snk;
        snk.in = –1;
        snk.out = 0;
        snk.connected = true;
      }

      public void write( int b )  throws IOException
      {
        if ( sink == null )
          throw new IOException( "Pipe not connected" );

        sink.receive( b );
      }
    }
Der PipedInputStream nutzt intern einen Puffer von standardmäßig 1024 Elementen. Das bedeutet: Der Schreibende kann standardmäßig bis zu 1024 Byte (oder Zeichen bei PipedReader) produzieren, bis die Kommunikation stoppen muss. Denn mit dieser Größe ist der Puffer voll und der Produzent blockiert; der Lesende muss den Puffer erst leeren, damit der Konsument weiterarbeiten darf. Umgekehrt bedeutet dies, dass der lesende Thread bei ungenügend vielen Zeichen warten muss, bis der Schreiber die nötige Anzahl hinterlegt hat. Dafür wird intern mittels Thread-Synchronisation gearbeitet. Lebt die andere Seite nicht mehr, gibt es eine IOException. Seit Java 6 lässt sich die Größe über einen Konstruktor wie PipedInputStream(int pipeSize), PipedInputStream(PipedOutputStream src, int pipeSize), PipedReader(int pipeSize) oder PipedReader(PipedWriter src, int pipeSize) setzen. ### 13.9.2 PipedWriter und PipedReader Die Klassen PipedWriter und PipedReader sind die char-Varianten für die sonst byte-orientierten Klassen PipedOutputStream und PipedInputStream. Diese sollen uns als Beispiel dienen. Zwei Threads arbeiten miteinander und tauschen Daten aus. Der eine Thread produziert Zufallszahlen, die ein anderer Thread auf dem Bildschirm darstellt. Listing 13.30 com/tutego/insel/io/stream/PipeDemo.java, PipeRandomWriter
    package com.tutego.insel.io.stream;

    import java.io.*;

    class PipeRandomWriter extends PipedWriter implements Runnable
    {
      public void run()
      {
        while ( true ) {
          try
          {
            write( String.format("%f%n", Math.random()) );
            Thread.sleep( 200 );
          }
          catch ( Exception e ) { e.printStackTrace(); }
        }
      }
    }
Der Thread ist eine Spezialisierung von PipedWriter und produziert in run() endlos Zufallszahlen, die in den Ausgabestrom vom PipedWriter geschoben werden. Der PipeRandomReader wiederum ist ein PipedReader, der über einen BufferedReader alle geschriebenen Zeilen ausliest. Listing 13.31 com/tutego/insel/io/stream/PipeDemo.java, PipeRandomReader
    class PipeRandomReader extends PipedReader implements Runnable
    {
      public void run()
      {
        BufferedReader br = new BufferedReader( this );

        while ( true )
          try
          {
            System.out.println( br.readLine() );
          }
          catch ( IOException e ) { e.printStackTrace(); }
      }
    }
Das Hauptprogramm erzeugt die beiden spezialisierten Pipes und verbindet sie. Danach werden die Threads gestartet. Listing 13.32 com/tutego/insel/io/stream/PipeDemo.java, PipeDemo
    public class PipeDemo
    {
      public static void main( String[] args ) throws Exception
      {
        PipeRandomWriter out = new PipeRandomWriter();
        PipeRandomReader in  = new PipeRandomReader();
        in.connect( out );

        new Thread( out ).start();
        new Thread( in ).start();
      }
    }
### 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