/*** Abstract class for reading character streams.  The only methods that a* subclass must implement are read(char[], int, int) and close().  Most* subclasses, however, will override some of the methods defined here in order* to provide higher efficiency, additional functionality, or both.*/
public abstract class Reader implements Readable, Closeable {/*** Attempts to read characters into the specified character buffer.* The buffer is used as a repository of characters as-is: the only* changes made are the results of a put operation. No flipping or* rewinding of the buffer is performed.*/public int read(java.nio.CharBuffer target) throws IOException {}/*** Reads a single character.  This method will block until a character is* available, an I/O error occurs, or the end of the stream is reached.*/public int read() throws IOException {}/*** Reads characters into an array.  This method will block until some input* is available, an I/O error occurs, or the end of the stream is reached.*/public int read(char cbuf[]) throws IOException {return read(cbuf, 0, cbuf.length);}/*** Reads characters into a portion of an array.  This method will block* until some input is available, an I/O error occurs, or the end of the* stream is reached.*/abstract public int read(char cbuf[], int off, int len) throws IOException;/*** Skips characters.  This method will block until some characters are* available, an I/O error occurs, or the end of the stream is reached.*/public long skip(long n) throws IOException {}/*** Tells whether this stream is ready to be read.*/public boolean ready() throws IOException {}/*** Closes the stream and releases any system resources associated with* it.  Once the stream has been closed, further read(), ready(),* mark(), reset(), or skip() invocations will throw an IOException.* Closing a previously closed stream has no effect.*/abstract public void close() throws IOException;
}

/*** Abstract class for writing to character streams.  The only methods that a* subclass must implement are write(char[], int, int), flush(), and close().* Most subclasses, however, will override some of the methods defined here in* order to provide higher efficiency, additional functionality, or both.*/
public abstract class Writer implements Appendable, Closeable, Flushable {/*** Writes a single character.  The character to be written is contained in* the 16 low-order bits of the given integer value; the 16 high-order bits* are ignored.*/public void write(int c) throws IOException {}/*** Writes an array of characters.*/public void write(char cbuf[]) throws IOException {write(cbuf, 0, cbuf.length);}/*** Writes a portion of an array of characters.*/abstract public void write(char cbuf[], int off, int len) throws IOException;/*** Writes a string.*/public void write(String str) throws IOException {write(str, 0, str.length());}/*** Writes a portion of a string.*/public void write(String str, int off, int len) throws IOException {}/*** Appends the specified character sequence to this writer.*/public Writer append(CharSequence csq) throws IOException {}/*** Appends a subsequence of the specified character sequence to this writer.*/public Writer append(CharSequence csq, int start, int end) throws IOException {}/*** Appends the specified character to this writer.*/public Writer append(char c) throws IOException {}/*** Flushes the stream.  If the stream has saved any characters from the* various write() methods in a buffer, write them immediately to their* intended destination.  Then, if that destination is another character or* byte stream, flush it.  Thus one flush() invocation will flush all the* buffers in a chain of Writers and OutputStreams.*/abstract public void flush() throws IOException;/*** Closes the stream, flushing it first. Once the stream has been closed,* further write() or flush() invocations will cause an IOException to be* thrown. Closing a previously closed stream has no effect.*/abstract public void close() throws IOException;}

An InputStreamReader is a bridge from byte streams to character streams: It
reads bytes and decodes them into characters using a specified
java.nio.charset.Charset charset.  The charset that it uses
may be specified by name or may be given explicitly, or the platform's
default charset may be accepted.

An OutputStreamWriter is a bridge from character streams to byte streams:
Characters written to it are encoded into bytes using a specified charset.  The charset that it uses may be specified by name or may be given explicitly, or the platform's default charset may be accepted.

public class StreamTest {public static void main(String[] args) throws Exception {//字节流FileOutputStream fos = new FileOutputStream("file.txt");//变成字符流OutputStreamWriter osw = new OutputStreamWriter(fos);//加上缓冲功能BufferedWriter bw = new BufferedWriter(osw);bw.write("http://www.google.com");bw.write("\n");bw.write("http://www.baidu.com");bw.close();FileInputStream fis = new FileInputStream("file.txt");InputStreamReader isr = new InputStreamReader(fis);BufferedReader br = new BufferedReader(isr);String str = br.readLine();while (null != str) {System.out.println(str);str = br.readLine();}br.close();}
}

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);

public class FileReader1 {public static void main(String[] args) throws Exception {File file = new File("c:\\CharSet.java");FileReader fr = new FileReader(file);BufferedReader br = new BufferedReader(fr);String str;while (null != (str = br.readLine())) {System.out.println(str);}br.close();}
}

public class FileWriter1 {public static void main(String[] args) throws IOException {String str = "hello world welcome nihao hehe";char[] buffer = new char[str.length()];str.getChars(0, str.length(), buffer, 0);FileWriter f = new FileWriter("file2.txt");for (int i = 0; i < buffer.length; i++) {f.write(buffer[i]);}f.close();}
}