Die Anleitung zu Java IO Character Streams

View more Tutorials:

1- Die Vorstellung

Im vorherigen Unterricht habe ich das input-output binary stream vorgestellt, Sie brauchen es vor dem Erkenntnis von input-output character stream studieren. Sie können hier sehen

2- Der Unterschied zwischen das Binary Stream und das Zeichen Stream

Das Binary stream, jedes Aufschreiben/Lesen einer byte (ca. 8 bit)
Inzwischen schreibt/liest das Character Stream ein Zeichen. Es ist abhängig von Encoding ( UTF-8, UTF-16,..), deren Zeichen 1, 2 oder 3 byte entsprechen. Wir sehen bitte das folgende Illustrationsbild:

UTF-16:

Das ist eine japanische Text. Wenn sie in der File mit der Encoding UTF-16 (UTF-16 encoding) gespeichert wird, ist die byte in der Festplatte so gleich wie das folgende Illustration
  • Die 2 ersten byte (254,255) bedeutet die Benachrichtigung, dass sie die Beginn des String mit UTF-16 encoding ist.
  • Die nächsten Zeichen werden durch 2 Byte encoded.
    • Zum Beispiel: Das Zeichen 'J' wird durch 2 byte (0 und 74) encoded
    • Das Zeichen 'P' wird durch 2 byte (0 und 80) encoded
    • ....
  • Bei Lesen der File mit UTF-16 encoding wird es 2 erste byte ignorieren und die 2 nächsten ununtergebrochen byte in einem Zeichen lesen

UTF-8:

Es wird unterschiedlich sein wenn die obengemeinte japanische Text durch  UTF-8 encoded wird. Sehen Sie bitte die  byte, die in der Festplatte gespeichert wird
  • Mit der ASCII Zeichen benutzt es nur eine byte für die Speicherung.
    • Zum Beispeil : es benutzt eine byte um das Zeichen 'J' (74) zu speichen.
    • Eine byte benutzen um das Zeichen 'P' (80) zu benutzen.
  • Die anderen Zeichen können 2 byte oder 3 byte zur Speicherung brauchen.
  • Die Regelung zum Lesen eines Zeichen nach der UTF-8 (UTF-8 Table).
    • Die erste byte lesen, wenn <= 127 ist, ist das ein Zeichen ASCII.
    • Umgekehrt wenn nếu > 127 ist, soll es die zweite byte und prüfen, ob 2 byte in einem Zeichen nach der UTF-8 Tabelle kombiert werden oder nicht.
    • Wenn 2 erste byte kein Zeichen entsprechen, soll es die dritte byte und in einem Zeichen kombinieren
    • UTF-8 benutzt maximal 3 byte um ein Zeichen zu speichen.

So wenn Sie eine Text mit irgendeiner Encoding speichen, sollen Sie die äquivalenten Encoding lesen , sonst das Output vom Lesen wird falsch sein

3- Die Überblick vom IO Charakter Stream

Die Hierarchie von der Klasse

4- Class java.io.Reader

Reader ist eine abstrakte Klasse. Sie ist die Grundlage für die Zeichen-Lesen Streams
Eine File test_reader.txt erstellen um mit einem Beispiel von Reader ​​​​​​​zu beginnen:
HelloReader.java
package org.o7planning.tutorial.javaio.readerwriter;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class HelloReader {

	public static void main(String[] args) throws IOException {
		// Erstellen Sie einen Reader (das Zeichenstream) um eine File zu lesen.
		// Mit der default encoding.
		Reader r = new FileReader("test_reader.txt");
		int i = -1;

		// Die Zeichen abwechselnd im Stream lesen.
		while ((i = r.read()) != -1) {
			// Cast in dem Zeichenstyp
			System.out.println((char) i);
		}
		r.close();
	}

}
Das Ergebnis der Beispielsdurchführung
Das nächste Beispiel  wird mehre Zeichen in Einmal lesen. Die Maßnahme erhöht die Leistung des Programm besser als das Lesen des einzelnen Zeichen
HelloReader2.java
package org.o7planning.tutorial.javaio.readerwriter;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

// Das Beispiel liest mehre Zeichen in Einmal.
public class HelloReader2 {

	public static void main(String[] args) throws IOException {

		// Ein Objekt Reader zum Lesen einer File erstellen.
		// Mit dem default encoding.
		Reader r = new FileReader("test_reader.txt");
		// Ein Array vorläufig erstellen
		char[] temp = new char[10];
		int i = -1;

		// Die Methode read(char[]):
		// mehre Zeichen in Einmal lesen und in die Wert des Array anweisen.
		// Die lesbaren Elemente zurückgeben.
		// -1 zurückgeben wenn das Stream endet
		while ((i = r.read(temp)) != -1) {
			String s = new String(temp, 0, i);
			System.out.println(s);
		}
		r.close(); 
	}

}

5- Class java.io.Writer

Writer ist eine abstrakte Klasse. Sie ist  eine Basic Klasse damit  der Stream das Zeichen schreibt
HelloWriter.java
package org.o7planning.tutorial.javaio.readerwriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class HelloWriter {

	public static void main(String[] args) throws IOException {
		File dir = new File("C:/test");

		// Den Verzeichnis 'C:/test' erstellen wenn er existiert nicht.
		dir.mkdirs();

		// Ein Objekt Writer erstellen um Daten in die File zu schreiben
		// Mit dem default encoding.
		Writer w = new FileWriter("C:/test/test_writer.txt");

		// Der Array des Zeichen.
		char[] chars = new char[] { 'H', 'e', 'l', 'l', 'o', // 
				' ', 'w', 'r', 'i', 't', 'e', 'r' };

		// Die Zeichen in Stream aufschreiben.
		for (int i = 0; i < chars.length; i++) {
			char ch = chars[i];
			int j = (int) ch;
			// 
			w.write(j);
		}
		// Das Stream schließen
		w.close();
	}
}
Das Ergebnis der Beispielsdurchführung
Das nächste Beispiel, mehre Zeichen in Stream einmal aufschreiben. Konkret schreiben Sie ein Array des Zeichen in Stream. Das erhöht die Leistung des Programm besser als das Aufschreiben der einzelnen Zeichen 
HelloWriter2.java
package org.o7planning.tutorial.javaio.readerwriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class HelloWriter2 {

	public static void main(String[] args) throws IOException {

		File dir = new File("C:/test");
		// Den Verzeichnis  'C:/test' erstellen wenn er existiert nicht.
		dir.mkdirs();

		// Ein Objekt Writer erstellen um die Daten in die File aufzuschreiben
		Writer w = new FileWriter("C:/test/test_writer2.txt");

		// 
		char[] chars = new char[] { 'H', 'e', 'l', 'l', 'o', //
				' ', 'w', 'r', 'i', 't', 'e', 'r' };

		// Alle Zeichen von Array in Stream aufschreiben
		w.write(chars);

		// Normaleweise benutzt Java den Puffer um die Daten vorläufig zu speichern
		// Wenn der Puffer voll ist, wird die Daten in die File geschoben (flush)
		// Sie können aktiv die Daten in die File schieben (flush).
		w.flush();

		// Die New-line-character in dem Stream aufschreiben.
		w.write('\n');

		String s = "FileWriter";

		// Ein String im Stream aufschreiben.
		w.write(s);

		// Das Stream schließen (close stream).
		// Es schiebt die Daten auf dem Puffer (buffer) in die File 
		// und gleichzeitig endet das Aufschreiben der Daten
		w.close();
	}
}
Das Ergebnis der Beispiel-durchführung

6- Wie wird die Umwandlung eines binäry Stream zu einem Zeichen-Stream gemacht?

Sie haben ein Binäry Stream (binary stream). Und Sie möchten es zu einem Zeichen Stream (character stream) wandeln?
In die oben Beispiele haben wir mit Reader, Writer kennengelernt. Das nächste Beispiel erlaubt Sie aktiv, die Daten in dem Stream mit einer konkreten Code zu lesen und aufzuschreiben
Die Erstellung einer File  test_utf8.txt
test_utf8.txt
JP日本-八洲
Beim  Save fragt  Eclipse Sie, mit welcher encoding wird es gespeichert. Bitte wählen Sie UTF-8.
InputStreamReaderExample.java
package org.o7planning.tutorial.javaio;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

public class InputStreamReaderExample {

	public static void main(String[] args) throws IOException {

		// Ein Binäry Stream zum File-Lesen erstellen.
		InputStream in = new FileInputStream("test_utf8.txt");

		// Ein Zeichen Stream erstellen um das obengemeinte Binäry Stream einzupacken (wrap).
		// Mit dem encoding als UTF-8.
		Reader reader = new InputStreamReader(in, "UTF-8");

		int i = 0;
		// die Zeichen einzeln lesen.
		while ((i = reader.read()) != -1) {
			// Cast in einen Zeichen und auf dem Bildschirm ausdrucken
			System.out.println((char) i + " " + i);
		}
		reader.close();
	}
}
Das Ergebnis der Beispiel-durchführung
Das nächste Beispiel: die  UTF-8 encoded File aufschreiben.
OutputStreamWriterExample.java
package org.o7planning.tutorial.javaio;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutputStreamWriterExample {

	public static void main(String[] args) throws IOException {
		
		File dir = new File("C:/test");
		// Den Verzeichnis  'C:/test' erstellen wenn er existiert nicht.
		dir.mkdirs();
		// Ein OutputStream erstellen um die Daten in die File aufzuschreiben.
		OutputStream out = new FileOutputStream("C:/test/test_write_utf8.txt");

		// Ein Character Stream (das Zeichen Stream) zur Packung des oben OutputStream erstellen.
		// Die Encoding ist UTF-8.
		Writer writer = new OutputStreamWriter(out, "UTF-8");

		String s = "JP日本-八洲";
		writer.write(s);
		writer.close();
	}

}
Das Ergebnis der Beispielsdurchführung

7- Class java.io.BufferedReader

Wenn Sie jede Datenzeile einer File lesen möchten, ist BufferedReader eine gute Auswahl
// BufferedReader ist eine direkte Sub-Klasse vom Reader .
// Constructor:
public BufferedReader(Reader in);

// Eine Utility Klasse aus BufferedReader.
// Eine Text-Zeile lesen
public String readLine();
Ví dụ:
// Zum Beispiel 1:
Reader r=new FileReader("C:/test.txt");
BufferedReader br=new BufferedReader(r);

// Zum Beispiel 2:
InputStream in = new FileInputStream("C:/test.txt");
Reader r = new InputStreamReader(in, "UTF-8");
BufferReader br = new BufferedReader(r);
test_multi_lines.txt
## Fruit List
Apricots
Barbados Cherries
Bitter Melon
Cherimoya
Honeydew
Jackfruit
Limes
Lychee
Mango
Oranges
Pineapple
Strawberries
BufferedReaderExample.java
package org.o7planning.tutorial.javaio.buffered;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

public class BufferedReaderExample {

	public static void main(String[] args) throws IOException {

		InputStream in = new FileInputStream("test_multi_lines.txt");
		Reader reader = new InputStreamReader(in, "UTF-8");
		BufferedReader br = new BufferedReader(reader);

		String s = null;
		int i = 0;

		// Jede Datenzeile (line) lesen.
		// Wenn Sie null lesen können, d.h Stream endet
		while ((s = br.readLine()) != null) {
			i++;
			System.out.println(i + " : " + s);
		}
		br.close();
	}

}
Das Ergebni der Beispieldurchführung

8- Class java.io.BufferedWriter

BufferedWriter ist eine direkte Subklasse von der Klasse Writer.
// Ein Objekt BufferedWriter 
// durch die Einpackung (wrap) eines anderen Objekt Writer erstellen.
public BufferedWriter(Writer out);

// so äquivalent wie write('\n');
public String newLine();
Zum Beispiel
// Ein Objekt Writer erstellen.
Writer w=new FileWriter("C:/test/test_bufferedWriter.txt");

// Ein Objekt BufferedWriter packend (wrap) eines writer erstellen.
BufferedWriter bw=new BufferedWriter(w);

bw.write("Hello..");

// Ein New-line Character '\n' aufschreiben.
bw.newLine();

9- Class java.io.FilterReader

FilterReader ist eine Subklasse der Klasse Reader. Er liest filternd die Zeichen nach der Bedarf. Zum Beispiel: Sie möchten ein HTML Text lesen und die Zeichen in Tags ignorieren, dann brauchen Sie eine Subklasse von FilterReader schreiben und diese Klasse benutzen. Sie können  FilterReader nicht direkt benutzen denn es ist eine abstrakte Klasse (abstract class).
Zum Beispiel: Die Erstellung einer Sub-Klasse von der Klasse FilterReader, die Daten HTML lesen aber die Zeichen im Tag ignorieren.
Zum Beispiel: Das Input  "<h1>Hello</h1>" ==> "Hello" lesen.
RemoveHTMLReader.java
package org.o7planning.tutorial.javaio.filter;

import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;

public class RemoveHTMLReader extends FilterReader {

	boolean intag = false;

	public RemoveHTMLReader(Reader in) {
		super(in);
	}

	// Wir schreibt die Methode über (override) .
	// Der Grundsatz liegt darin:
	// Nur die Zeichen außer Tag lesen.
	@Override
	public int read(char[] buf, int from, int len) throws IOException {

		int charCount = 0;

		while (charCount == 0) {

			charCount = super.read(buf, from, len);
			if (charCount == -1) {
				// Stream enden
				return -1;
			}

			int last = from;

			for (int i = from; i < from + charCount; i++) {
				// Im Tag HTML liegen.
				if (!intag) {
					if (buf[i] == '<') {
						intag = true;
					} else {
						buf[last++] = buf[i];
					}
				} else if (buf[i] == '>') {
					intag = false;
				}
			}

			charCount = last - from;
		}
		return charCount;
	}

	// auch die Methode überschreiben
	@Override
	public int read() throws IOException {
		char[] buf = new char[1];
		int result = read(buf, 0, 1);
		if (result == -1) {
			return -1;
		} else {
			return (int) buf[0];
		}
	}
}
RemoveHTMLReaderTest.java
package org.o7planning.tutorial.javaio.filter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;

public class RemoveHTMLReaderTest {

	public static void main(String[] args) throws IOException {

		// Ein Objekt Reader aus dem Constructor vom StringReader
		Reader in = new StringReader("<h1>Hello \n <b>World</b><h1>");

		RemoveHTMLReader filterReader = new RemoveHTMLReader(in);
		BufferedReader br = new BufferedReader(filterReader);

		String s = null;
		while ((s = br.readLine()) != null) {
			System.out.println(s);
		}
		br.close();
	}
}
Das Ergebnis der Beispieldurchführung

10- Class java.io.FilterWriter

FilterWriter ist eine Sub-Klasse vom  Writer. Er schreibt filternd die Zeichen nach dem Bedarf. Sie brauchen eine Sub-Klasse vom FilterWriter schreiben und einige Methode von der Klasse   FilterWriter ​​​​​​​überschreiben.
Zum Beispiel: Die Zeichen wird geändert wenn sie in dem Stream aufgeschrieben werden
Rot13.java
package org.o7planning.tutorial.javaio.filter;

public class Rot13 {
    
    /**
     * <pre>
     *   a ==> n
     *   b ==> o
     *   c ==> p
     *   d ==> q
     *   e ==> r
     *   ...
     *   y ==> l
     *   z ==> m
     * </pre>
     */
    public static int rotate(int inChar) {
        int outChar;
        
        if (inChar >= (int) 'a' && inChar <= (int) 'z') {
            outChar = (((inChar - 'a') + 13) % 26) + 'a';
        } else if (inChar >= (int) 'A' && inChar <= (int) 'Z') {
            outChar = (((inChar - 'A') + 13) % 26) + 'A';
        } else {
            outChar = inChar;
        }
        return outChar;
    }
    
    // Test
    public static void main(String[] args)  {
        for(char ch='a'; ch<='z';ch++ ) {
            char m= (char)rotate(ch);
            System.out.println("ch="+ch+" ==> "+ m);    
        }      
        
    }
}
RotateWriter.java
package org.o7planning.tutorial.javaio.filter;

import java.io.FilterWriter;
import java.io.IOException;
import java.io.Writer;

public class RotateWriter extends FilterWriter {
 
	public RotateWriter(Writer out) {
		super(out);
	}

	// Eine oder mehre Methode überschreiben um die Filter zu behandeln 
	// (das Überschreibung der 2 Methode wird mehr sicher)
	@Override
	public void write(int outChar) throws IOException {
		super.write(Rot13.rotate(outChar));
	}

	@Override
	public void write(char[] cbuf, int offset, int length) throws IOException {
		char[] tempbuf = new char[length];
		for (int i = 0; i < length; i++) {
			tempbuf[i] = (char) Rot13.rotate(cbuf[offset + i]);
		}
		super.write(tempbuf, 0, length);
	}

}
RotateWriterTest.java
package org.o7planning.tutorial.javaio.filter;

import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;

public class RotateWriterTest {

    
    public static void main(String[] args) throws IOException  {
        String s="abcdef";
        
        Writer writer= new StringWriter();
        
        RotateWriter rw= new RotateWriter(writer);
        rw.write(s.toCharArray(),0,s.length());
        
        rw.close();
        
        String rotateString = writer.toString();
        System.out.println("rotateString="+ rotateString);
    }
}
 
Das Ergebnis der Beispieldurchführung

11- Class java.util.PushbackReader

Die Klasse  PushbackReader erlaubt ein oder mehre Zeichen, für das Stream nach dem Lesen wieder zu geben (push back). Unten sind das die 2 Constructor von ihm
public PushbackReader(Reader inputStream)

public PushbackReader(Reader inputStream, int bufSize)
Einige zusätzlichen Methode
// Ein Zeichen ins Stream zurück stellen (push back)
public void unread(int c) throws IOException
Zum Beispiel
PushbackReaderDemo.java
package org.o7planning.tutorial.javaio.pushback;

import java.io.CharArrayReader;
import java.io.IOException;
import java.io.PushbackReader;

class PushbackReaderDemo {

	public static void main(String args[]) throws IOException {
		String s = "if (a == 4) a = 0;\\n";
		char buf[] = new char[s.length()];
		s.getChars(0, s.length(), buf, 0);
		CharArrayReader in = new CharArrayReader(buf);
		PushbackReader f = new PushbackReader(in);
		int c;
		while ((c = f.read()) != -1) {
			switch (c) {
			// Das Zeichen '=' fanden
			case '=':
				// Ein Zeichen noch mehr lesen.
				// (nach der Findung des Zeichen '=' ).
				if ((c = f.read()) == '=') {
					System.out.print(".eq.");
				}

				else {
					System.out.print("<-");
					// Das Zeichen aufs Stream zurück stellen (Pushes back) 
					// Wie den Mauszeiger eine Position hinter stellen.
					f.unread(c);
				}
				break;
			default:
				System.out.print((char) c);
				break;
			}
		}
	}

}
Das Ergebnis der Beispielsdurchführung:

12- Class java.io.PrintWriter

// Constructor:
// Ein Objekt Writer einpacken (wrap) .
public PrintWriter(Writer out) 
public PrintWriter(Writer out,boolean autoFlush)

// Ein Objekt OutputStream einpacken (wrap) 
public PrintWriter(OutputStream out) 
public PrintWriter(OutputStream out,boolean autoFlush)
public PrintWriter(String fileName)
...

// Method:
public void println(String s)
public void print(char ch)
StackTraceToFile.java
package org.o7planning.tutorial.javaio.printwriter;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.Writer;

public class StackTraceToFile {

	public static void main(String[] args) {
		try {
			// Etwas hier machen.
			// Der Fehler über die Division durch 0.
			int i = 10 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				File dir = new File("C:/test");
				// Den Verzeichnis erstellen wenn er existiert.
				dir.mkdirs();
				// Ein Stream erstellen um die Daten in die File aufzuschreiben.
				Writer w = new FileWriter("C:/test/stackTrace.txt");
				
				// Das Objekt PrintWriter erstellen um das Objekt Writer 'w' einzupacken.
				// Deshalb wird die in PrintWriter aufgeschriebene Daten in FileWriter 'w' aufgeschrieben.
				PrintWriter pw = new PrintWriter(w);

				// Die Fehlerinformation im Stream 'pw' aufschreiben.
				e.printStackTrace(pw);
				System.out.println("Finish !");
			} catch (Exception e1) {
				System.out.println("Error:" + e);
			}
		}
	}

}
StackTraceToString.java
package org.o7planning.tutorial.javaio.printwriter;

import java.io.PrintWriter;
import java.io.StringWriter;

public class StackTraceToString {

	public static void main(String[] args) {
		try {
			// Hier etwas machen. Der Fehler von der Division durch 0.
			int i = 1000 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				StringWriter sw = new StringWriter();
				// Das Objekt PrintWriter zur Einpackung von StringWriter 'sw' erstellen. 
				// Deshalb wird die in PrintWriter in 'sw' aufgeschrieben.
				PrintWriter pw = new PrintWriter(sw);

				// Die Fehlerinformation in 'pw' aufschreiben.
				e.printStackTrace(pw);

				StringBuffer sb = sw.getBuffer();
				String s = sb.toString();
				System.out.println("Exception String:");
				System.out.println(s);
			} catch (Exception e1) {
				System.out.println("Error:" + e);
			}
		}

	}

}
Das Ergebnis der Beispielsdurchführung

13- Class java.io.CharArrayReader

CharArrayReaderDemo.java
package org.o7planning.tutorial.javaio.chararray;

import java.io.CharArrayReader;
import java.io.IOException;

public class CharArrayReaderDemo {
    
    public static void main(String args[]) throws IOException {
        
        String tmp = "abcdefghijklmnopqrstuvwxyz";
        int length = tmp.length();
        char c[] = new char[length];
        tmp.getChars(0, length, c, 0);
        
        CharArrayReader input1 = new CharArrayReader(c);
        CharArrayReader input2 = new CharArrayReader(c, 0, 5);
        
        int i;
        System.out.println("input1 is:");
        while ((i = input1.read()) != -1) {
            System.out.print((char) i);
        }
        System.out.println();
        System.out.println("input2 is:");
        while ((i = input2.read()) != -1) {
            System.out.print((char) i);
        }
        System.out.println();
    }
}
Das Ergebnis der Beispielsdurchführung

14- Class java.io.CharArrayWriter

Einige zusätzlichen Methode
// Die Daten von einem Stream in anderem Stream aufschreiben
public void writeTo(Writer out) throws IOException
CharArrayWriterDemo.java
package org.o7planning.tutorial.javaio.chararray;

import java.io.CharArrayWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class CharArrayWriterDemo {

	public static void main(String args[]) throws IOException {

		char[] c = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!' };
		CharArrayWriter out = new CharArrayWriter();
		// Die Daten in 'out' schreiben
		// Write characters in array to 'out'.
		out.write(c);

		File dir = new File("C:/test");
		dir.mkdirs();

		FileWriter f1 = new FileWriter(new File("C:/test/a.txt"));

		// Die Daten vom 'out' in 'f1' schreiben.
		out.writeTo(f1);

		FileWriter f2 = new FileWriter(new File("C:/test/b.txt"));

		// Die Daten vom 'out' in 'f2' schreiben.
		out.writeTo(f2);

		f1.close();
		f2.close();

		// Das Stream CharArrayWriter 'out' schließen.
		out.close();

		FileWriter f3 = new FileWriter(new File("C:/test/c.txt"));

		// Mit CharArrayWriter nach der Schließung.
		// Die Methode writeTo(..) hat keine Auswirkungen 
		// und verursacht keine Ausnahme wenn Sie writeTo(..) benutzen.
		out.writeTo(f3);

		System.out.println("Done!");
	}
}

15- Class java.io.PipedReader

  • TODO
PipeReaderExample1.java
package org.o7planning.tutorial.javaio.pipereader;

import java.io.IOException;
import java.io.Reader;
import java.io.PipedReader;
import java.io.PipedWriter;

public class PipeReaderExample1 {

	private Reader pipedReader;

	public static void main(String[] args) throws IOException, InterruptedException {
		new PipeReaderExample1().test();
	}

	private void test() throws IOException, InterruptedException {
		// Create a 'pipedWriter',
		PipedWriter pipedWriter = new PipedWriter();

		// Data writing to 'pipedWriter'
		// will automatically appear in 'pipedReader'.
		pipedReader = new PipedReader(pipedWriter);

		new ThreadRead().start();

		char[] chs = new char[] { 'a', 'a', 'b', 'c' , 'e' };

		// Write data to 'pipedWriter'.
		for (char ch : chs) {
			pipedWriter.write(ch);
			Thread.sleep(1000);
		}
		pipedWriter.close();
	}

	// A Thread to read the data that appears on 'pipedReader'.
	class ThreadRead extends Thread {

		@Override
		public void run() {
			try {
				int data = 0;
				while ((data = pipedReader.read()) != -1) {
					System.out.println((char) data);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				closeQuietly(pipedReader);
			}
		}
	}

	private void closeQuietly(Reader is) {
		if (is != null) {
			try {
				is.close();
			} catch (IOException e) {
			}
		}
	}

}
PipeReaderExample2.java
package org.o7planning.tutorial.javaio.pipereader;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.Reader;

public class PipeReaderExample2 {

	private BufferedReader bufferedReader;

	public static void main(String[] args) throws IOException, InterruptedException {
		new PipeReaderExample2().test();
	}

	private void test() throws IOException, InterruptedException {
		// Create a 'pipedWriter',
		PipedWriter pipedWriter = new PipedWriter();

		// Data writing to 'pipedWriter'
		// will automatically appear in 'pipedReader'.
		PipedReader pipedReader = new PipedReader(pipedWriter);
		
		// Tạo một 'bufferedReader' wrapped 'pipedReader'.
		bufferedReader = new BufferedReader(pipedReader);

		new ThreadRead().start();

		String[] strs = new String[] { "Hello ", "There", "\n", "I am ", "Tran" };

		// Write data to 'pipedWriter'.
		for (String str : strs) {
			pipedWriter.write(str);
			Thread.sleep(500);
		}
		pipedWriter.close();
	}

	// A Thread to read the data that appears on 'bufferedReader' ('pipedReader').
	class ThreadRead extends Thread {

		@Override
		public void run() {
			try {
				String line = null;
				while ((line = bufferedReader.readLine()) != null) {
					System.out.println(line);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				closeQuietly(bufferedReader);
			}
		}
	}

	private void closeQuietly(Reader reader) {
		if (reader != null) {
			try {
				reader.close();
			} catch (IOException e) {
			}
		}
	}

}

16- Class java.io.PipedWriter

View more Tutorials: