Le Tutoriel de Java IO Character Streams

View more categories:

1- Introduction

Dans le document d'instructions précédent, j'ai introduit le flux binaire d'entrée-sortie (input-output binary stream). Vous devez le comprendre avant d'apprendre du flux de caractères d'entrée-sortie (input-output character stream). Vous pouvez voir ici :
  • TODO Link!

2- La différence entre les flux binaires et les flux textes

Le flux binaire (binary stream), chacun lit / écrit un byte (octet) (équivalent à 8 bits)
Pendant ce temps, le flux textes (character stream) lit / écrit un caractère. Il dépend du type de codage (encoding) ( UTF-8, UTF-16, ...) pour décider du nombre de byte (octet) dans chaque tour de lecture / d'écriture qui sont de 1 octet, 2 octets ou 3 octets. Voyons l'image illustrée suivante:

UTF-16:

Ceci est un texte japonais. Si elle est stockée dans un fichier UTF-16 codé (UTF-16 encoding), les byte dans le lecteur de disque dur seront similaires à l'image illustrée:
  • Les deux premiers byte (254,255) ignifient notifier le début d'une chaîne avec un codage UTF-16.
  • Les caractères suivants sont codés par 2 byte.
    • Par exemple, le caractère 'J' est codé par 2 byte (0 et 74)
    • Le caractère 'P' est codé par 2 byte (0 et 80)
    • ....
  • Lors de la lecture d'un fichier avec un codage UTF-16, elle ignorera 2 premiers byte, et lira 2 byte consécutifs dans un caractère.

UTF-8:

Ce sera différent si le même texte japonais mentionné ci-dessus est codé par UTF-8. Vous pouvez voir que les byte sont stockés dans le lecteur de disque dur :
  • Avec des caractères ASCII, il utilisera seulement 1 byte pour le stockage.
    • Par exemple, il a besoin d'un byte pour stocker le caractère 'J' (74).
    • Il prend 1 byte pour stocker le caractère 'P' (80).
  • Des caractères peuvent utiliser 2 byte ou 3 byte pours stocker des autres caractères.
  • Dans la règle de lecture, à la base du tableau de codage UTF-8 (UTF-8 Table).
    • LIre le premier byte, si <= 127, ce sera un caractère ASCII.
    • Sinon, si > 127, il doit lire le deuxième byte, et vérifier si ces 2 byte là peuvent être combinés en un seul caractère basé de le tableau du codage  UTF-8 ou non.
    • Si les 2 premiers byte ne correspondent pas à 1 caractère, il lira byte suivant et les combinera en un caractère.
    • UTF-8 utilise maximum 3 byte afin de stocker un caracère.

En résumé, lorsque vous enregistrez un document avec un encodage (encoding) quelconque, vous devez lire avec un codage équivalent, sinon la sortie de lecture sera fausse.

3- Vue d'ensemble des flux textes

Les hiérarchie des classes :

4- Class java.io.Reader

Reader est une classe abstraite. c'est la classe de base pour les flux de lecture textes.
Créez un fichier  test_reader.txt pour commencer un exemple avec  Reader:
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 {
		// Créez un Reader (Le flux textes), pour lire un fichier.
		// Avec le codage (encoding) par défaut.
		Reader r = new FileReader("test_reader.txt");
		int i = -1;

		// Lisez chaque caractère à leur tour dans le flux.
		while ((i = r.read()) != -1) {
			// Changez (cast) en caractère.
			System.out.println((char) i);
		}
		r.close();
	}

}
Exécutez de l'exemple :
L'exemple suivant consiste à lire plusieurs caractères dans un tour de lecture. Cela permet d'améliorer l'efficacité du programme par rapport à la lecture de chaque caractère lors de son tour.
HelloReader2.java
package org.o7planning.tutorial.javaio.readerwriter;

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

// Cet exemple, lire plusieurs caractères en une fois.
public class HelloReader2 {

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

		// Créez un objet Reader pour lire un ficher.
		// Avec l'encodage (encoding) par défaut.
		Reader r = new FileReader("test_reader.txt");
		// Créer un tableau de caractères temporaire.
		char[] temp = new char[10];
		int i = -1;

		// La méthode read(char[]):
		// Lire plusieurs caractères à la fois et leur attribuer des éléments du tableau.
		// Renvoyer le nombre de caractères lus.
		// Ou renvoie -1 si la fin du flux (stream) termine.
		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 est une classe abstraite, elle est la classe de base de flux de caractères.
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");

		// Créez le répertoire 'C:/test', s'il n'existe pas.
		dir.mkdirs();

		// Créez un objet Writer, pour écrire des données dans le fichier.
		// En utilisant de l'encodage (encoding).
		Writer w = new FileWriter("C:/test/test_writer.txt");

		// Le tableau de caractères
		char[] chars = new char[] { 'H', 'e', 'l', 'l', 'o', // 
				' ', 'w', 'r', 'i', 't', 'e', 'r' };

		// Écrivez respectivement des caractères dans le flux (stream).
		for (int i = 0; i < chars.length; i++) {
			char ch = chars[i];
			int j = (int) ch;
			// 
			w.write(j);
		}
		// Fermez le flux (Close stream),
		w.close();
	}
}
Les résultats de l'exécution de l'exemple :
L'exemple suivant consiste à écrire plusieurs caractères dans un flux en même temps. Plus précisément, nous écrivons un tableau de caractères dans un flux. Cela permet d'améliorer l'efficacité du programme par rapport à l'écriture de chaque caractère lors de son tour.
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");
		// Créez le répertoire 'C:/test' s'il n'existe pas.
		dir.mkdirs();

		// Créez un objet Writer pour écrire les données dans le fichier.
		Writer w = new FileWriter("C:/test/test_writer2.txt");

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

		// Écrivez tous les caractères dans le flux.
		w.write(chars);

		// Java utilise souvent des tampons (buffer)
		// pour stocker temporairement des données.
		// Lorsque le tampon (buffer) est plein,  il vide (flush) les données dans le fichier.
		// Vous pouvez vider (flush) les données de manière proactive dans le fichier.
		w.flush();

		// Ghi ký tự xuống dòng (new line character) vào luồng.
		w.write('\n');

		String s = "FileWriter";

		// Ghi một chuỗi vào luồng (stream).
		w.write(s);

		// Đóng luồng (Close stream).
		// Nó sẽ đẩy các dữ liệu trên bộ đệm (buffer) vào file.
		// Đồng thời kết thúc việc ghi dữ liệu.
		w.close();
	}
}
Les résultats de l'exécution de l'exemple :

6- Comment un flux binaire est converti en un flux des caractères ?

Vous avez un flux binaire (binary stream). ET vous voulez le convertir en un flux des caractères (character stream)?
Dans les exemples ci-dessus, nous nous habituons à Reader and Writer. L'exemple suivant vous permet de lire et d'écrire activement dans le flux avec un codage clairement spécifié.
Créez un fichier  test_utf8.txt
test_utf8.txt
JP日本-八洲
Lorsque vous  Save, Eclipse vous demandera quelle sorte de codage que vous voulez enregistrer. Sélectionnez  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 {

		// Créez un binary Stream (un flux binaire), pour lire un fichier.
		InputStream in = new FileInputStream("test_utf8.txt");

		// Créez un Character stream (un flux de caractères) enveloppe (wrap) ce ledit flux binaire.
		// Avec le codage (encoding) est UTF-8.
		Reader reader = new InputStreamReader(in, "UTF-8");

		int i = 0;
		// Lisez respectivement des caractères.
		while ((i = reader.read()) != -1) {
			// Moulez (cast) en un caractère et l'imprimez sur l'écran.
			System.out.println((char) i + " " + i);
		}
		reader.close();
	}
}
Les résultats de l'exécution de l'exemple :
L'exemple suivant, écrit le fichier encodé avec UTF-8.
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");
		// Créez le répertoire 'C:/test' s'il n'existe pas.
		dir.mkdirs();
		// Créez un OutputStream (un flux de sortie) pour écrire des données dans un fichier.
		OutputStream out = new FileOutputStream("C:/test/test_write_utf8.txt");

		// Créez un Character Stream (un flux de caractères) qui contient ce OutputStream en haut.
		// Le codage (encoding) utilisé est UTF-8.
		Writer writer = new OutputStreamWriter(out, "UTF-8");

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

}
Les résultats de l'exécution de l'exemple

7- Class java.io.BufferedReader

Si vous voulez lire chaque ligne de données d'un fichier texte. BufferedReader est un bon choix.
// BufferedReader est une sous-classe directe de Reader .
// Constructor:
public BufferedReader(Reader in);

// Une méthode utilitaire de BufferedReader.
// Lire une ligne de texte
public String readLine();
Ví dụ:
// Exemple 1:
Reader r=new FileReader("C:/test.txt");
BufferedReader br=new BufferedReader(r);

// Exemple 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;

		// Lire chaque ligne (line) de données.
		// S'il renvoie null, cela signifie de la termination du Stream.
		while ((s = br.readLine()) != null) {
			i++;
			System.out.println(i + " : " + s);
		}
		br.close();
	}

}
Les résultats de l'exécution de l'exemple :

8- Class java.io.BufferedWriter

BufferedWriter est une sous- classe directe de la classe  Writer.
// Créez un objet BufferedWriter
// par l'emballage (wrap) un autre Writer.
public BufferedWriter(Writer out);

// Équivalent à write('\n');
public String newLine();
Exemple :
// Créez l'objet Writer.
Writer w=new FileWriter("C:/test/test_bufferedWriter.txt");

// Créez un objet BufferedWriter enveloppe (wrap) un writer.
BufferedWriter bw=new BufferedWriter(w);

bw.write("Hello..");

// Écrivez une nouvelle ligne de caractères '\n'.
bw.newLine();

9- Class java.io.FilterReader

FilterReader est une sous- classe de la classe Reader.
Il lit sélectivement des caractères à la demande. Par exemple, vous voulez lire un document HTML et ignorer les caractères dans les étiquette (tag). Vous devez écrire une sous-classe de FilterReader, puis utiliser cette sous-classe. Vous ne pouvez pas utiliser directement FilterReader puisqu'il s'agit d'une classe abstraite (abstract class).
Par exemple, créez une sous-classe de  FilterReader, pour lire des données du document  HTML mais ignorer des caractères dans l'étiquette.
L'entrée :  "<h1>Hello</h1>" ==> La sortie :  "Hello".
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);
	}

	// Remplacez (override) cette méthode.
	// Le principe serait:
	// Seulement lire les caractères en dehors des étiquettes (tag).
	@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) {
				// Terminez le flux.
				return -1;
			}

			int last = from;

			for (int i = from; i < from + charCount; i++) {
				// Si ce n'est pas dans une étiquette HTML.
				if (!intag) {
					if (buf[i] == '<') {
						intag = true;
					} else {
						buf[last++] = buf[i];
					}
				} else if (buf[i] == '>') {
					intag = false;
				}
			}

			charCount = last - from;
		}
		return charCount;
	}

	// Remplacez également cette méthode.
	@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 {

		// Créez un objet Reader à partir du Constructeur du 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();
	}
}
Les résultats de l'exécution d'exemple :

10- Class java.io.FilterWriter

FilterWriter est une sous-classe directe de  Writer. Il écrit sélectivement des caractères à la demande. Vous devez écrire une sous-classe de FilterWriter et remplacer (override) certaines méthodes de la classe FilterWriter.
Exemple : Des caractères ont changé lorsque vous écriivez au flux.
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);
	}

	// Remplacer une ou plusieurs méthodes d'écriture pour effectuer le filtrage.
	// (Remplacer toutes les deux pour être sûr)
	@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);
    }
}
 
Les résultats de l'exécution d'exemple :

11- Class java.util.PushbackReader

La classe  PushbackReader permet un ou plusieurs caractères d'être revenu(s) (push back) au flux après de le(s) avoir lu(s). Ci-dessous sont leurs deux constructeurs :
public PushbackReader(Reader inputStream)

public PushbackReader(Reader inputStream, int bufSize)
Ajoutez quelques méthodes supplémentaires :
// Renvoie (push back) une caractère au flux.
public void unread(int c) throws IOException
Exemple :
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) {
			// Trouvé le caractère '='
			case '=':
				// Lisez le caractère suivant.
				// (Après d'avoir trouvé le caractère '=').
				if ((c = f.read()) == '=') {
					System.out.print(".eq.");
				}

				else {
					System.out.print("<-");
					// Repoussez (Pushes back) le caractère au flux.
					// Comme - déplacez le curseur d'une position vers l'arrière.
					f.unread(c);
				}
				break;
			default:
				System.out.print((char) c);
				break;
			}
		}
	}

}
Les résultats de l'exécution d'exemple :

12- Class java.io.PrintWriter

// Constructeur:
// Enveloppe (wrap) un objet Writer.
public PrintWriter(Writer out) 
public PrintWriter(Writer out,boolean autoFlush)

// Enveloppe (wrap) un objet OutputStream.
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 {
			// Faites quelque chose.
			// L'erreur de division par 0.
			int i = 10 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				File dir = new File("C:/test");
				// Créez des répertoires s'ils n'existent pas.
				dir.mkdirs();
				// Créez un flux (Stream) pour éccrire des données au fichier.
				Writer w = new FileWriter("C:/test/stackTrace.txt");
				
				// Créez l'objet PrintWriter qui enveloppe l'objet Writer 'w'.
				// Des données qui sont écrits dans PrintWriter sera poussé au 'w'.
				PrintWriter pw = new PrintWriter(w);

				// Écrivez des informations erronées 'pw'.
				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 {
			// Faites quelque chose.
			// L'erreur de division par 0.
			int i = 1000 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				StringWriter sw = new StringWriter();
				// Créez l'objet PrintWriter qui enveloppe l'objet Writer 'sw'.
				// Des données qui sont écrits dans PrintWriter sera poussé au 'sw'.
				PrintWriter pw = new PrintWriter(sw);

				// Écrivez des informations erronées 'pw'.
				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);
			}
		}

	}

}
Les résultats de l'exécution d'exemple :

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();
    }
}
Les résultats de l'exécution d'exemple :

14- Class java.io.CharArrayWriter

Ajoutez quelques méthodes supplémentaires :
// Écrivez le contenu de ce flux dans un autre flux des caractères.
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();
		// Écrivez des données au tableau 'out'
		out.write(c);

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

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

		// Écrivez des données du 'out' au 'f1'.
		out.writeTo(f1);

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

		// Écrivez des données du 'out' au 'f2'.
		out.writeTo(f2);

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

		// Fermer le flux CharArrayWriter 'out'.
		out.close();

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

		// Avec CharArrayWriter, après fermer.
		// La méthode writeTo(..) ne fonctionne plus.
		// Et elle ne se produit pas d'exception si vous utilisez writeTo(..).
		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 categories: