Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Neues in Java 7
2 Threads und nebenläufige Programmierung
3 Datenstrukturen und Algorithmen
4 Raum und Zeit
5 Dateien, Verzeichnisse und Dateizugriffe
6 Datenströme
7 Die eXtensible Markup Language (XML)
8 Dateiformate
9 Grafische Oberflächen mit Swing
10 Grafikprogrammierung
11 Netzwerkprogrammierung
12 Verteilte Programmierung mit RMI
13 RESTful und SOAP Web-Services
14 JavaServer Pages und Servlets
15 Applets
16 Datenbankmanagement mit JDBC
17 Technologien für die Infrastruktur
18 Reflection und Annotationen
19 Dynamische Übersetzung und Skriptsprachen
20 Logging und Monitoring
21 Java Native Interface (JNI)
22 Sicherheitskonzepte
23 Dienstprogramme für die Java-Umgebung
Stichwort
Download: - openbook, ca. 21,3 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / Java 7 - Mehr als eine Insel | vor >>
Java 7 - Mehr als eine Insel von Christian Ullenboom Das Handbuch zu den Java SE-Bibliotheken
Java 7 - Mehr als eine Insel Galileo Computing 1433 S., 2012, geb. 49,90 Euro, ISBN 978-3-8362-1507-7 |
| 6 Datenströme
|  | 6.1 Stream-Klassen und Reader/Writer am Beispiel von Dateien
|  |  | 6.1.1 Mit dem FileWriter Texte in Dateien schreiben
|  |  | 6.1.2 Zeichen mit der Klasse FileReader lesen
|  |  | 6.1.3 Kopieren mit FileOutputStream und FileInputStream
|  |  | 6.1.4 Das FileDescriptor-Objekt *
|  |  | 6.1.5 Datenströme über Files mit NIO.2 beziehen
|  | 6.2 Basisklassen für die Ein-/Ausgabe
|  |  | 6.2.1 Die abstrakten Basisklassen
|  |  | 6.2.2 Übersicht über Ein-/Ausgabeklassen
|  |  | 6.2.3 Die abstrakte Basisklasse OutputStream
|  |  | 6.2.4 Die Schnittstellen Closeable, AutoCloseable und Flushable
|  |  | 6.2.5 Ein Datenschlucker *
|  |  | 6.2.6 Die abstrakte Basisklasse InputStream
|  |  | 6.2.7 Ressourcen aus dem Klassenpfad und aus Jar?Archiven laden
|  |  | 6.2.8 Ströme mit SequenceInputStream zusammensetzen *
|  |  | 6.2.9 Die abstrakte Basisklasse Writer
|  |  | 6.2.10 Die Schnittstelle Appendable *
|  |  | 6.2.11 Die abstrakte Basisklasse Reader
|  | 6.3 Formatierte Textausgaben
|  |  | 6.3.1 Die Klassen PrintWriter und PrintStream
|  |  | 6.3.2 System.out, System.err und System.in
|  | 6.4 Schreiben und Lesen aus Strings und Byte-Feldern
|  |  | 6.4.1 Mit dem StringWriter ein String-Objekt füllen
|  |  | 6.4.2 CharArrayWriter
|  |  | 6.4.3 StringReader und CharArrayReader
|  |  | 6.4.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben
|  |  | 6.4.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen
|  | 6.5 Datenströme filtern und verketten
|  |  | 6.5.1 Streams als Filter verketten (verschachteln)
|  |  | 6.5.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream
|  |  | 6.5.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream
|  |  | 6.5.4 LineNumberReader zählt automatisch Zeilen mit *
|  |  | 6.5.5 Daten mit der Klasse PushbackReader zurücklegen *
|  |  | 6.5.6 DataOutputStream/DataInputStream *
|  |  | 6.5.7 Basisklassen für Filter *
|  |  | 6.5.8 Die Basisklasse FilterWriter *
|  |  | 6.5.9 Ein LowerCaseWriter *
|  |  | 6.5.10 Eingaben mit der Klasse FilterReader filtern *
|  |  | 6.5.11 Anwendungen für FilterReader und FilterWriter *
|  | 6.6 Vermittler zwischen Byte-Streams und Unicode-Strömen
|  |  | 6.6.1 Datenkonvertierung durch den OutputStreamWriter
|  |  | 6.6.2 Automatische Konvertierungen mit dem InputStreamReader
|  | 6.7 Kommunikation zwischen Threads mit Pipes *
|  |  | 6.7.1 PipedOutputStream und PipedInputStream
|  |  | 6.7.2 PipedWriter und PipedReader
|  | 6.8 Prüfsummen
|  |  | 6.8.1 Die Schnittstelle Checksum
|  |  | 6.8.2 Die Klasse CRC32
|  |  | 6.8.3 Die Adler32-Klasse
|  | 6.9 Persistente Objekte und Serialisierung
|  |  | 6.9.1 Objekte mit der Standard-Serialisierung speichern und lesen
|  |  | 6.9.2 Zwei einfache Anwendungen der Serialisierung *
|  |  | 6.9.3 Die Schnittstelle Serializable
|  |  | 6.9.4 Nicht serialisierbare Attribute aussparen
|  |  | 6.9.5 Das Abspeichern selbst in die Hand nehmen
|  |  | 6.9.6 Tiefe Objektkopien *
|  |  | 6.9.7 Versionenverwaltung und die SUID
|  |  | 6.9.8 Wie die ArrayList serialisiert *
|  |  | 6.9.9 Probleme mit der Serialisierung
|  | 6.10 Alternative Datenaustauschformate
|  |  | 6.10.1 Serialisieren in XML-Dateien
|  |  | 6.10.2 XML-Serialisierung von JavaBeans mit JavaBeans Persistence *
|  |  | 6.10.3 Die Open-Source-Bibliothek XStream *
|  |  | 6.10.4 Binäre Serialisierung mit Google Protocol Buffers *
|  | 6.11 Tokenizer *
|  |  | 6.11.1 StreamTokenizer
|  | 6.12 Zum Weiterlesen
# 6 Datenströme »Wer zur Quelle will, muss gegen den Strom schwimmen.« – Danny Kaye (1913–1987) Um an die Information einer Datei oder an andere Ressourcen zu gelangen, müssen wir den Inhalt auslesen können. Das geht für Dateien mit einer Klasse wie RandomAccessFile, allerdings funktioniert so etwas nicht bei Daten, die etwa aus dem Internet kommen, denn hier gibt es keinen wahlfreien Zugriff. Hier rückt ein anderes Konzept in den Mittelpunkt: der Datenstrom (engl. stream). Dieser entsteht beim Fluss der Daten von der Eingabe über die Verarbeitung hin zur Ausgabe. Mittels Datenströmen können Daten sehr elegant bewegt werden; ein Programm ohne Datenfluss ist eigentlich undenkbar. Die Eingabeströme (engl. input streams) sind zum Beispiel Daten der Tastatur oder vom Netzwerk; über die Ausgabeströme (engl. output streams) fließen die Daten in ein Ausgabemedium, beispielsweise in den Drucker oder in eine Datei. Die Kommunikation der Threads erfolgt über Pipes. In Java sind über dreißig Klassen zur Verarbeitung der Datenströme vorgesehen. Da die Datenströme an kein spezielles Ein- oder Ausgabeobjekt gebunden sind, können sie beliebig miteinander gemischt werden. Dies ist mit dem elektrischen Strom vergleichbar: Es gibt mehrere Stromlieferanten (Solarkraftwerke, Nutzung geothermischer Energie, Umwandlung von Meereswärmeenergie [OTEC]) und mehrere Verbraucher (Wärmedecke, Mikrowelle), die die Energie wieder umsetzen. ## 6.1 Stream-Klassen und Reader/Writer am Beispiel von Dateien Unterschiedliche Klassen zum Lesen und Schreiben von Binär- und Zeichendaten sammeln sich im Paket java.io. Für die byte-orientierte Verarbeitung, etwa von PDF- oder MP3-Dateien, gibt es andere Klassen als für Textdokumente, zum Beispiel HTML oder Konfigurationsdateien. Binär- von Zeichendaten zu trennen ist sinnvoll, da zum Beispiel beim Einlesen von Textdateien diese immer in Unicode konvertiert werden müssen, da Java intern alle Zeichen in Unicode kodiert. Die vier Basisklassen sind die zeichenorientierten Klassen Reader, Writer und die byte-orientierten Klassen InputStream und OutputStream. #### FileInputStream, FileReader, FileOutputStream, FileWriter Dieser Abschnitt stellt die vier Klassen zum Lesen und Schreiben aus Dateien vor, und zwar jeweils die zeichen- und byte-orientierten Klassen.

Tabelle 6.1: Lese- und Schreibklassen für Dateien

| Bytes (oder Byte-Arrays) | Zeichen (oder Zeichen-Arrays, Strings)
Aus Dateien lesen | FileInputStream | FileReader
In Dateien schreiben | FileOutputStream | FileWriter
Hinweis
Lies den ganzen Dateiinhalt in ein Byte-Feld:
    File f = new File( dateiname );
    byte[] buffer = new byte[ (int) f.length() ];
    InputStream in = new FileInputStream( f );
    in.read( buffer );
    in.close();
Sinnvoller als das gesamte Einlesen ist aber im Allgemeinen das Lesen in Blöcken. Eine korrekte Fehlerbehandlung ist immer notwendig, wird aber hier erst einmal ausgeblendet.
### 6.1.1 Mit dem FileWriter Texte in Dateien schreiben Der FileWriter ist ein spezieller Writer, der Ausgaben in eine Datei erlaubt. Das folgende Programm erstellt die Datei fileWriter.txt und schreibt eine Textzeile mit Zeilenvorschubzeichen hinein: Listing 6.1: com/tutego/insel/io/stream/FileWriterDemo.java, main()
    Writer fw = null;

    try
    {
      fw = new FileWriter( "fileWriter.txt" );
      fw.write( "Zwei Jäger treffen sich..." );
      fw.append( System.getProperty("line.separator") ); // e.g. "\n"
    }
    catch ( IOException e ) {
      System.err.println( "Konnte Datei nicht erstellen" );
    }
    finally {
      if ( fw != null )
        try { fw.close(); } catch ( IOException e ) { e.printStackTrace(); }
    }
Da der Konstruktor und die write()/append()-Methoden eine IOException in dem Fall auslösen, wenn ein Öffnen beziehungsweise Schreiben nicht möglich ist, müssen wir einen try-Block um die Anweisungen setzen oder mit throws den Fehler nach oben weitergeben.
    class java.io.FileWriter
    extends OutputStreamWriter
FileWriter(File file) throws IOException FileWriter(String filename) throws IOException FileWriter(File file, boolean append) throws IOException FileWriter(String filename, boolean append) throws IOException Erzeugt einen Ausgabestrom und hängt die Daten an eine existierende Datei an, wenn append gleich true ist. Eine weitere Möglichkeit, Daten hinten anzuhängen, bietet die Klasse RandomAccessFile oder FileOutputStream. FileWriter(FileDescriptor fd) Erzeugt einen Ausgabestrom zum Schreiben in eine Datei. Existiert die Datei bereits, deren Namen wir übergeben, wird die Datei gelöscht. Auf den ersten Blick scheinen der Klasse FileWriter die versprochenen write()-Methoden zu fehlen. Fakt ist aber, dass diese von OutputStreamWriter geerbt werden, und die Klasse erbt und überschreibt wiederum die Methoden aus Writer. Mit den Oberklassen verfügt der FileWriter insgesamt über folgende Methoden, deren Ausnahme IOException hier nicht genannt ist: Writer append(char c) Writer append(CharSequence csq) Writer append(CharSequence csq, int start, int end) void write(int c) void write(String str) void write(String str, int off, int len) void write(char[] cbuf) void write(char[] cbuf, int off, int len) void close() void flush() String getEncoding() Bis auf getEncoding() lösen alle verbleibenden Methoden im Fehlerfall eine IOException aus, die als geprüfte Ausnahme behandelt werden muss. Die Methoden stellt Abschnitt 6.2.9, »Die abstrakte Basisklasse Writer«, genauer vor. ### 6.1.2 Zeichen mit der Klasse FileReader lesen Der FileReader liest aus Dateien entweder einzelne Zeichen, Strings oder Zeichenfelder. Wie beim Writer deklariert die Klasse Konstruktoren zur Annahme des Dateinamens. So zeigt folgendes Beispiel eine Anwendung der FileReader-Klasse: Listing 6.2: com/tutego/insel/io/stream/FileReaderDemo.java, main()
    Reader reader = null;
    try
    {
      reader = new FileReader( "bin/lyrics.txt" );

      for ( int c; ( c = reader.read() ) != –1; )
        System.out.print( (char) c );
    }
    catch ( IOException e ) {
      System.err.println( "Fehler beim Lesen der Datei!" );
    }
    finally {
      try { reader.close(); } catch ( Exception e ) { e.printStackTrace(); }
    }
    class java.io.FileReader
    extends InputStreamReader
public FileReader(String fileName) throws FileNotFoundException Öffnet die Datei über einen Dateinamen zum Lesen. Falls sie nicht vorhanden ist, löst der Konstruktor eine FileNotFoundException aus. public FileReader(File file) throws FileNotFoundException Öffnet die Datei zum Lesen über ein File-Objekt. Falls sie nicht verfügbar ist, löst der Konstruktor eine FileNotFoundException aus. public FileReader(FileDescriptor fd) Nutzt die schon vorhandene offene Datei über ein FileDescriptor-Objekt. Die Methoden zum Lesen stammen aus den Oberklassen InputStreamReader und Reader. Aus InputStreamReader kommen int read(), int read(char[], int, int), close(), getEncoding() und ready(). Da InputStreamReader wiederum Reader erweitert, kommen die Methoden int read(char[]), int read(CharBuffer), mark(int), markSupported(), reset(), skip(long) hinzu. Abschnitt 6.2.11, »Die abstrakte Basisklasse Reader«, beschreibt die Methoden genauer. ### 6.1.3 Kopieren mit FileOutputStream und FileInputStream Die Klasse FileOutputStream bietet grundlegende Methoden, um in Dateien zu schreiben. FileOutputStream implementiert alle nötigen Methoden, die java.io.OutputStream vorschreibt, also etwa write(int), write(byte[]).
    class java.io.FileOutputStream
    extends OutputStream
FileOutputStream(String name) throws FileNotFoundException Erzeugt einen FileOutputStream mit einem gegebenen Dateinamen. FileOutputStream(File file) throws FileNotFoundException Erzeugt einen FileOutputStream aus einem File-Objekt. FileOutputStream(String name, boolean append) throws FileNotFoundException Wie FileOutputStream(name), hängt jedoch bei append=true Daten an. FileOutputStream(File file, boolean append) throws FileNotFoundException Wie FileOutputStream(file), hängt jedoch bei append=true Daten an. FileOutputStream(FileDescriptor fdObj) Erzeugt einen FileOutputStream aus einem FileDescriptor-Objekt. Ist der Parameter append nicht mit true belegt, wird der alte Inhalt überschrieben. Die FileNotFoundException wirkt vielleicht etwas komisch, wird aber dann ausgelöst, wenn zum Beispiel die Dateiangabe ein Verzeichnis repräsentiert oder die Datei gelockt ist. FileInputStream ist der Gegenspieler und dient zum Lesen der Binärdaten. Um ein Objekt anzulegen, haben wir die Auswahl zwischen drei Konstruktoren. Sie binden eine Datei (etwa repräsentiert als ein Objekt vom Typ File) an einen Datenstrom.
    class java.io.FileInputStream
    extends InputStream
FileInputStream(String name) throws FileNotFoundException Erzeugt einen FileInputStream mit einem gegebenen Dateinamen. FileInputStream(File file) throws FileNotFoundException Erzeugt FileInputStream aus einem File-Objekt. FileInputStream(FileDescriptor fdObj) Erzeugt FileInputStream aus einem FileDescriptor-Objekt. Der FileInputStream ist ein spezieller InputStream und besitzt daher Methoden wie int read(), int read(byte[]) zum Lesen. Zur Veranschaulichung dient die folgende Grafik. Abbildung 6.1: UML-Diagramm der Klassen FileInputStream und FileOutputStream #### Kopieren von Dateien * Als Beispiel für das Zusammenspiel von FileInputStream und FileOutputStream wollen wir ein Datei-Kopierprogramm entwerfen. Es ist einleuchtend, dass wir zunächst die Quelldatei öffnen müssen. Taucht ein Fehler auf, wird dieser zusammen mit allen anderen Fehlern in einer besonderen IOException-Fehlerbehandlung ausgegeben. Wir trennen hier die Fehler nicht besonders. Nach dem Öffnen der Quelle wird eine neue Datei angelegt. Das erledigt der Konstruktor FileOutputStream, dem es jedoch gleichgültig ist, ob es bereits eine Datei dieses Namens gibt; wenn, dann überschreibt er sie gnadenlos. Auch darum kümmern wir uns nicht. Wollten wir das berücksichtigen, sollten wir mithilfe der File-Klasse prüfen, ob eine gleichnamige Datei existiert. Nach dem Anlegen können wir Byte für Byte auslesen und kopieren. Die Lösung über diesen nativen Weg ist natürlich in puncto Geschwindigkeit erbärmlich. Eine Lösung wäre, einen Dekorator dazwischenzuschalten, den BufferedInputStream. Doch das ist nicht nötig, weil wir einen Puffer mit read(byte[]) selbst füllen können. Da diese Methode die Anzahl tatsächlich gelesener Bytes zurückliefert, schreiben wir diese direkt mittels write() in den Ausgabepuffer. Hier erbringt eine Pufferung über eine Zwischen-Puffer-Klasse keinen Geschwindigkeitsgewinn, da wir ja selbst einen 64-KiB-Puffer einrichten: Listing 6.3: com/tutego/insel/io/stream/cp.java
    package com.tutego.insel.io.stream;

    import java.io.*;

    public class cp
    {
      static void copy( InputStream in, OutputStream out ) throws IOException
      {
        byte[] buffer = new byte[ 0xFFFF ];
        for ( int len; (len = in.read(buffer)) != –1; )
          out.write( buffer, 0, len );
      }

      static void copyFile( String src, String dest )
      {
        FileInputStream  fis = null;
        FileOutputStream fos = null;

        try
        {
          fis = new FileInputStream( src );
          fos = new FileOutputStream( dest );

          copy( fis, fos );
        }
        catch ( IOException e ) {
          e.printStackTrace();
        }
        finally {
          if ( fis != null )
            try { fis.close(); } catch ( IOException e ) { e.printStackTrace(); }
          if ( fos != null )
            try { fos.close(); } catch ( IOException e ) { e.printStackTrace(); }
        }
      }

      public static void main( String[] args )
      {
        if ( args.length != 2 )
          System.err.println( "Benutzung: copy <src> <dest>" );
        else
          copyFile( args[0], args[1] );
      }
    }
Der Klassenname ist hier – entgegen üblicher Konventionen – klein- und kryptisch geschrieben, um dem Charakter eines Kommandozeilenprogramms zu entsprechen.
Hinweis
Apache Commons IO (http://jakarta.apache.org/commons/io/) bietet über die Klasse IOUtils fertige copy()-Methoden. Auch NIO.2 bietet copy()-Methoden an.
### 6.1.4 Das FileDescriptor-Objekt * Die Klasse java.io.FileDescriptor repräsentiert eine offene Datei (oder eine Socket-Verbindung) mittels eines Deskriptors. Er lässt sich bei File-Objekten mit getFD() erfragen, aber nicht von Hand gültig aufbauen.[45](Die Socket-Klasse selbst bietet keine Methode zum Abfragen eines Deskriptors. Nur Unterklassen von SokketImpl (und DatagramSocketImpl) ist der Zugriff über eine protected-Methode getFileDescriptor() gestattet.) In der Regel kommt der Entwickler mit keinem FileDescriptor-Objekt in Kontakt. Es gibt allerdings eine Anwendung, in der die Klasse FileDescriptor nützlich ist: Sie bietet eine sync()-Methode an, die im internen Puffer des Betriebssystems verbleibende Speicherblöcke auf das Gerät schreibt. Damit lässt sich erreichen, dass Daten auch tatsächlich auf dem Datenträger materialisiert werden. Die Stream-Objekte (OutputStream/Writer) haben auch eine Methode flush(), der vergleichbare Funktionalität zuzuschreiben ist, jedoch kümmert sich flush() nur um das Leeren des Puffers, nicht allerdings um das tatsächliche Schreiben, also Materialisieren auf einem Hintergrundspeicher. Ist der Java-Puffer mit flush() geleert, können die Daten trotzdem noch in einem internen Puffer des Betriebssystems liegen – aber auf den hat flush() keinen Einfluss, nur sync().
Beispiel
Arbeite mit einem Ausgabestrom, und materialisiere alle Änderungen:
    FileOutputStream os = new FileOutputStream( ... );
    os.write( ... );
    os.flush();
    FileDescriptor fd = os.getFD();
    fd.sync();
Neben FileInputStream kennen auch FileOutputStream und RandomAccessFile eine Methode getFD(). Mit einem FileDescriptor kann auch die Arbeit zwischen Stream-Objekten und RandomAccessFile-Objekten koordiniert werden.
    final class java.io.FileDescriptor
void sync() Materialisiert die Daten. sync() kehrt erst dann zum Aufrufer zurück, wenn die Daten geschrieben wurden. ### 6.1.5 Datenströme über Files mit NIO.2 beziehen Anstatt einen FileInputStream oder einen FileOutputStream mit einem Dateinamen oder File-Objekt anzulegen, bietet die Files-Klasse zwei Methoden, die direkt den Eingabe-/Ausgabestrom liefern:
    final abstract java.nio.file.Files
static OutputStream newOutputStream(Path path, OpenOption... options) Legt eine Datei an und liefert den Ausgabestrom auf die Datei. static InputStream newInputStream(Path path, OpenOption... options) Öffnet die Datei und liefert einen Eingabestrom zum Lesen. Da die OpenOption ein Vararg ist und somit weggelassen werden können, ist der Programmcode kurz. (Er wäre noch kürzer ohne die korrekte Fehlerbehandlung...) #### Beispiel: Eine kleine PPM-Grafikdatei schreiben Das PPM-Format ist ein einfaches Grafikformat. Es beginnt mit einem Identifizierer, dann folgenden die Ausmaße und schließlich die ARGB-Werte für die Pixelfarben. Listing 6.4: com/tutego/insel/nio2/WriteTinyPPM.java, main()
    try ( OutputStream out = Files.newOutputStream( Paths.get( "littlepic.ppm" ) ) )
    {
      out.write( "P3 1 1 255 255 0 0".getBytes() );
    }
    catch ( IOException e )
    {
      e.printStackTrace();
    }
Falls die Datei nicht existiert, wird sie überschrieben; existiert sie nicht, wird sie neu angelegt. Diese Standardoption ist aber ein wenig zu einschränkend, und daher beschreibt OpenOption Zusatzoptionen. OpenOption ist eine Schnittstelle, die von den Aufzählungen LinkOption, StandardOpenOption realisiert wird.

Tabelle 6.2: Konstanten aus StandardOpenOption und LinkOption

OpenOption | Beschreibung
java.nio.file.StandardOpenOption
READ | Öffnen für Lesezugriff
WRITE | Öffnen für Schreibzugriff
APPEND | Neue Daten kommen an das Ende. Atomar bei parallelen Schreiboperationen.
TRUNCATE_EXISTING | Für Schreiber: Existiert die Datei, wird die Länge vorher auf 0 gesetzt.
CREATE | Legt Datei an, falls sie noch nicht existiert.
CREATE_NEW | Legt Datei nur an, falls sie vorher noch nicht existierte.
DELETE_ON_CLOSE | Die Java-Bibliothek versucht, die Datei zu löschen, wenn sie geschlossen wird.
SPARSE | Hinweis für das Dateisystem, die Datei kompakt zu speichern, da sie aus vielen Null-Bytes besteht
SYNC | Jeder Schreibzugriff und jedes Update der Metadaten soll sofort zum Dateisystem.
DSYNC | Jeder Schreibzugriff soll sofort zum Dateisystem.
java.nio.file.LinkOption
NOFOLLOW_LINKS | Symbolischen Links wird nicht gefolgt.
Die Option CREATE_NEW kann nur funktionieren, wenn die Datei noch nicht vorhanden ist. Das zeigt anschaulich das folgende Beispiel: Listing 6.5: com/tutego/insel/nio2/StandardOpenOptionCreateNewDemo.java, main()
    Files.deleteIfExists( Paths.get( "opa.herbert.tmp" ) );
    Files.newOutputStream( Paths.get( "opa.herbert.tmp" ) ).close();
    Files.newOutputStream( Paths.get( "opa.herbert.tmp" ) ).close();
    Files.newOutputStream( Paths.get( "opa.herbert.tmp" ),
                           StandardOpenOption.CREATE_NEW ).close();
Hier führt die letzte Zeile zu einer »java.nio.file.FileAlreadyExistsException: opa.herbert .tmp«. Die Option DELETE_ON_CLOSE ist für temporäre Dateien nützlich. Das folgende Beispiel verdeutlicht die Arbeitsweise: Listing 6.6: com/tutego/insel/nio2/StandardOpenOptionDeleteOnCloseDemo.java, main()
    Path path = Paths.get( "opa.herbert.tmp" );

    Files.deleteIfExists( path );
    System.out.println( Files.exists( path ) );   // false

    Files.newOutputStream( path ).close();
    System.out.println( Files.exists( path ) );   // true

    Files.newOutputStream( path, StandardOpenOption.DELETE_ON_CLOSE,
                                 StandardOpenOption.SYNC ).close();
    System.out.println( Files.exists( path ) );   // false
Im letzten Fall wird die Datei angelegt, ein Datenstrom geholt und gleich wieder geschlossen. Wegen StandardOpenOption.DELETE_ON_CLOSE wird Java die Datei von sich aus löschen, was Files.exists() belegt. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück | <top> | vor >>
Zum Katalog
Java 7 – Mehr als eine Insel Jetzt bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Buchempfehlungen
| Java und XML
| Einstieg in Eclipse 3.7
| Android 3
| NetBeans Platform 7
| Java ist auch eine Insel
| Apps entwickeln für Android 4
| Java 7
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2012
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das 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