Hướng dẫn sử dụng luồng vào ra ký tự trong 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 {
		// Tạo một Reader (Luồng ký tự), để đọc một file.
		// Với mã hóa (encoding) mặc định.
		Reader r = new FileReader("test_reader.txt");
		int i = -1;

		// Đọc lần lượt từng ký tự trong luồng.
		while ((i = r.read()) != -1) {
			// Ép về (cast) thành kiểu ký tự.
			System.out.println((char) i);
		}
		r.close();
	}

}

package org.o7planning.tutorial.javaio.readerwriter;

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

// Ví dụ này sẽ đọc nhiều ký tự trong một lần.
public class HelloReader2 {

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

		// Tạo một đối tượng Reader đọc một file.
		// Với mã hóa (encoding) mặc định. 
		Reader r = new FileReader("test_reader.txt");
		// Tạo một mảng tạm.
		char[] temp = new char[10];
		int i = -1;

		// Phương thức read(char[]):
		// Đọc nhiều ký tự trong một lần, và gán vào các phần tử của mảng. 
		// Trả về số ký tự đọc được.
		// Trả về -1 nếu luồng (stream) kết thúc.
		while ((i = r.read(temp)) != -1) {
			String s = new String(temp, 0, i);
			System.out.println(s);
		}
		r.close(); 
	}

}

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");

		// Tạo thư mục 'C:/test', nếu nó chưa tồn tại.
		dir.mkdirs();

		// Tạo một đối tượng Writer, để ghi dữ liệu vào file.
		// Với mã hóa (encoding) mặc định.
		Writer w = new FileWriter("C:/test/test_writer.txt");

		// Mảng các ký tự.
		char[] chars = new char[] { 'H', 'e', 'l', 'l', 'o', // 
				' ', 'w', 'r', 'i', 't', 'e', 'r' };

		// Ghi lần lượt các ký tự vào luồng (stream).
		for (int i = 0; i < chars.length; i++) {
			char ch = chars[i];
			int j = (int) ch;
			// 
			w.write(j);
		}
		// Đóng luồng (Close stream),
		w.close();
	}
}

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");
		// Tạo thư mục 'C:/test' nếu nó chưa tồn tại.
		dir.mkdirs();

		// Tạo một đối tượng Writer, để ghi dữ liệu vào file.
		Writer w = new FileWriter("C:/test/test_writer2.txt");

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

		// Ghi tất cả các ký tự trong mảng vào luồng.
		w.write(chars);

		// Thông thường Java sử dụng bộ đệm (buffer)
		// để lưu trữ dữ liệu một cách tạm thời.
		// Khi bộ đệm (buffer) đầy, dữ liệu sẽ được đẩy (flush) xuống file.
		// Bạn cũng có thể chủ động đẩy (flush) dữ liệu xuống file.
		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();
	}
}

JP日本-八洲

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 {

		// Tạo một binary Stream (luồng nhị phân), để đọc file.
		InputStream in = new FileInputStream("test_utf8.txt");

		// Tạo một Character stream (luồng ký tự) bao lấy (wrap) luồng nhị phân trên.
		// Với mã hóa (encoding) là UTF-8.
		Reader reader = new InputStreamReader(in, "UTF-8");

		int i = 0;
		// Đọc lần lượt từng ký tự.
		while ((i = reader.read()) != -1) {
			// Ép kiểu (cast) thành một ký tự và in ra màn hình.
			System.out.println((char) i + " " + i);
		}
		reader.close();
	}
}

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");
		// Tạo thư mục 'C:/test' nếu nó không tồn tại.
		dir.mkdirs();
		// Tạo một OutputStream (luồng đầu ra) để ghi dữ liệu vào file.
		OutputStream out = new FileOutputStream("C:/test/test_write_utf8.txt");

		// Tạo một Character Stream (luồng ghi ký tự) bao lấy OutputStream ở trên.
		// Mã hóa (encoding) là UTF-8.
		Writer writer = new OutputStreamWriter(out, "UTF-8");

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

}

// BufferedReader là một lớp con trực tiếp của Reader .
// Constructor:
public BufferedReader(Reader in);

// Một phương thức tiện lợi có được từ BufferedReader.
// Đọc một dòng văn bản.
public String readLine();

// Ví dụ 1:
Reader r=new FileReader("C:/test.txt");
BufferedReader br=new BufferedReader(r);

// Ví dụ 2:
InputStream in = new FileInputStream("C:/test.txt");
Reader r = new InputStreamReader(in, "UTF-8");
BufferReader br = new BufferedReader(r);

## Fruit List
Apricots
Barbados Cherries
Bitter Melon
Cherimoya
Honeydew
Jackfruit
Limes
Lychee
Mango
Oranges
Pineapple
Strawberries

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;

		// Đọc từng dòng (line) dữ liệu.
		// Nếu đọc được null nghĩa là kết thúc Stream.
		while ((s = br.readLine()) != null) {
			i++;
			System.out.println(i + " : " + s);
		}
		br.close();
	}

}

// Tạo một đối tượng BufferedWriter 
// bằng cách gói (wrap) một đối tượng Writer khác.
public BufferedWriter(Writer out);

// Tương đương với write('\n'); 
public String newLine();

// Tạo đối tượng Writer.
Writer w=new FileWriter("C:/test/test_bufferedWriter.txt");

// Tạo một đối tượng BufferedWriter bao lấy (wrap) một writer.
BufferedWriter bw=new BufferedWriter(w);

bw.write("Hello..");

// Ghi một ký tự xuống dòng '\n'.
bw.newLine();

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);
	}

	// Chúng ta ghi đè (override) phương thức này.
	// Nguyên tắc sẽ là:
	// Chỉ đọc các ký tự nằm ngoài các thẻ (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) {
				// Kết thúc stream.
				return -1;
			}

			int last = from;

			for (int i = from; i < from + charCount; i++) {
				// Nếu không nằm trong thẻ HTML.
				if (!intag) {
					if (buf[i] == '<') {
						intag = true;
					} else {
						buf[last++] = buf[i];
					}
				} else if (buf[i] == '>') {
					intag = false;
				}
			}

			charCount = last - from;
		}
		return charCount;
	}

	// Cũng cần ghi đè phương thức này.
	@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];
		}
	}
}

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 {

		// Tạo một đối tượng Reader từ Constructor của 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();
	}
}

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);    
        }      
        
    }
}

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);
	}

	// Ghi đè một hoặc nhiều phương thức để sử lý việc lọc.
	// (Ghi đè cả 2 phương thức sẽ an toàn hơn).
	@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);
	}

}

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);
    }
}

public PushbackReader(Reader inputStream)

public PushbackReader(Reader inputStream, int bufSize)

// Đặt trở lại (push back) một ký tự về luồng.
public void unread(int c) throws IOException

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) {
			// Tìm thấy ký tự '='
			case '=':
				// Đọc tiếp một ký tự nữa.
				// (Sau khi đã tìm thấy ký tự '=' trước đó).
				if ((c = f.read()) == '=') {
					System.out.print(".eq.");
				}

				else {
					System.out.print("<-");
					// Đẩy trở lại (Pushes back) ký tự này lên luồng.
					// Giống như lùi con trỏ trở lại 1 vị trí.
					f.unread(c);
				}
				break;
			default:
				System.out.print((char) c);
				break;
			}
		}
	}

}

// Constructor:
// Bao bọc (wrap) một đối tượng Writer.
public PrintWriter(Writer out) 
public PrintWriter(Writer out,boolean autoFlush)

// Bao bọc (wrap) một đối tượng 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)

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 {
			// Làm một việc gì đó.
			// Lỗi chia cho 0.
			int i = 10 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				File dir = new File("C:/test");
				// Tạo thư mục nếu nó không tồn tại.
				dir.mkdirs();
				// Tạo một Stream để ghi dữ liệu vào file.
				Writer w = new FileWriter("C:/test/stackTrace.txt");
				
				// Tạo đối tượng PrintWriter bao lấy đối tượng Writer 'w'.
				// Như vậy dữ liệu ghi vào PrintWriter sẽ được ghi vào FileWriter 'w'.
				PrintWriter pw = new PrintWriter(w);

				// Ghi thông tin lỗi vào luồng 'pw'.
				e.printStackTrace(pw);
				System.out.println("Finish !");
			} catch (Exception e1) {
				System.out.println("Error:" + e);
			}
		}
	}

}

package org.o7planning.tutorial.javaio.printwriter;

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

public class StackTraceToString {

	public static void main(String[] args) {
		try {
			// Làm một việc gì đó
			// Lỗi chia cho 0.
			int i = 1000 / 0;
		} catch (Exception e) {
			System.out.println("EXCEPTION ....");
			try {
				StringWriter sw = new StringWriter();
				// Tạo đối tượng PrintWriter bao lấy StringWriter 'sw'.
				// Như vậy dữ liệu ghi vào PrintWriter sẽ ghi vào 'sw'.
				PrintWriter pw = new PrintWriter(sw);

				// Ghi thông tin lỗi vào '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);
			}
		}

	}

}

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();
    }
}

// Ghi dữ liệu của luồng này sang một luồng khác.
public void writeTo(Writer out) throws IOException

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();
		// Ghi dữ liệu vào 'out'
		// 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"));

		// Ghi dữ liệu của 'out' vào 'f1'.
		out.writeTo(f1);

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

		// Ghi dữ liệu từ 'out' vào 'f2'.
		out.writeTo(f2);

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

		// Đóng luồng CharArrayWriter 'out'.
		out.close();

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

		// Với CharArrayWriter, sau khi đóng.
		// Phương thức writeTo(..) không còn có tác dụng.
		// Và cũng không gây ra ngoại lệ nếu bạn sử dụng writeTo(..).
		out.writeTo(f3);

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

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 {
		// Tạo một 'pipedWriter',
		PipedWriter pipedWriter = new PipedWriter();

		// Dữ liệu ghi vào 'pipedWriter'
		// sẽ tự động xuất hiện tại 'pipedReader'.
		pipedReader = new PipedReader(pipedWriter);

		new ThreadRead().start();

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

		// Ghi dữ liệu vào 'pipedWriter'.
		for (char ch : chs) {
			pipedWriter.write(ch);
			Thread.sleep(1000);
		}
		pipedWriter.close();
	}

	// Một Thread đọc dữ liệu xuất hiện trên '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) {
			}
		}
	}

}

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 {
		// Tạo một 'pipedWriter',
		PipedWriter pipedWriter = new PipedWriter();

		// Dữ liệu ghi vào 'pipedWriter'
		// sẽ tự động xuất hiện tại 'pipedReader'.
		PipedReader pipedReader = new PipedReader(pipedWriter);
		
		// Tạo một 'bufferedReader' bao lấy 'pipedReader'.
		bufferedReader = new BufferedReader(pipedReader);

		new ThreadRead().start();

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

		// Ghi dữ liệu vào 'pipedWriter'.
		for (String str : strs) {
			pipedWriter.write(str);
			Thread.sleep(500);
		}
		pipedWriter.close();
	}

	// Một Thread đọc dữ liệu xuất hiện trên '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) {
			}
		}
	}

}