Die Anleitung zu Java IO Character Streams

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

}

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

}

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

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

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 {

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

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

}

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

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

## 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;

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

}

// Ein Objekt BufferedWriter 
// durch die Einpackung (wrap) eines anderen Objekt Writer erstellen.
public BufferedWriter(Writer out);

// so äquivalent wie write('\n');
public String newLine();

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

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

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

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

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

}

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)

// Ein Zeichen ins Stream zurück stellen (push back)
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) {
			// 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;
			}
		}
	}

}

// 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)

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

}

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

	}

}

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

// Die Daten von einem Stream in anderem Stream aufschreiben
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();
		// 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!");
	}
}

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

}

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

}