InputStreamReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\Test11.txt"));

        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + isr.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + isr.ready());
        //read() int 读取单个字符。
        System.out.println("read():" + isr.read());
        char[] chars1 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        isr.read(chars1);
        System.out.println("read(char[] cbuf):" + new String(chars1));
        char[] chars2 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        isr.read(chars2, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars2));
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        isr.skip(1);
        //close() void 关闭该流并释放与之关联的所有系统资源。
        isr.close();
    }
}

E:\Test11.txt为CharArrayWriter输出

FileReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("E:\\Test11.txt");

        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + fr.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + fr.ready());
        //read() int 读取单个字符。
        System.out.println("read():" + fr.read());
        char[] chars1 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        fr.read(chars1);
        System.out.println("read(char[] cbuf):" + new String(chars1));
        char[] chars2 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        fr.read(chars2, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars2));
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        fr.skip(1);
        //close() void 关闭该流并释放与之关联的所有系统资源。
        fr.close();
    }
}

PushbackReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        PushbackReader pr = new PushbackReader(new FileReader("E:\\Test.txt"),1024);

        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + pr.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + pr.ready());
        //read() int 读取单个字符。
        System.out.println("read():" + pr.read());
        char[] chars1 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        pr.read(chars1);
        System.out.println("read(char[] cbuf):" + new String(chars1));
        char[] chars2 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        pr.read(chars2, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars2));
        //unread(char[] cbuf, int off, int len) void 推回字符数组的某一部分，方法是将其复制到推回缓冲区的前面。
        pr.unread(chars2, 0, 13);
        //unread(char[] cbuf) void 推回一个字符数组，方法是将其复制到推回缓冲区前面。
        pr.unread(chars1);
        //unread(int c) void 推回单个字符：将其复制到推回缓冲区的前面。
        pr.unread(97);
        //reset() void 重置该流。
        pr.reset();
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        pr.skip(1);
        //close() void 关闭该流并释放与之关联的所有系统资源。
        pr.close();
    }
}

CharArrayReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        char[] chars1 = new char[512];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        CharArrayReader car = new CharArrayReader(chars1);
        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + car.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + car.ready());
        //mark(int readAheadLimit) void 标记流中的当前位置。
        car.mark(0);
        //read() int 读取单个字符。
        System.out.println("read():" + car.read());
        char[] chars2 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        car.read(chars2);
        System.out.println("read(char[] cbuf):" + new String(chars2));
        char[] chars3 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        car.read(chars3, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars3));
        //reset()  void 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        car.reset();
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        car.skip(1);
        //close() void 关闭该流并释放与之关联的所有系统资源。
        car.close();
    }
}

BufferedReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new FileReader("E:\\Test11.txt"),1024);

        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + br.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + br.ready());
        //mark(int readAheadLimit) void 标记流中的当前位置。
        br.mark(1024);
        //read() int 读取单个字符。
        System.out.println("read():" + br.read());
        char[] chars1 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        br.read(chars1);
        System.out.println("read(char[] cbuf):" + new String(chars1));
        char[] chars2 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        br.read(chars2, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars2));
        //reset()  void 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        br.reset();
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        br.skip(1);
        //readLine() String 读取一个文本行。
        System.out.println("readLine():" + br.readLine());
        //close() void 关闭该流并释放与之关联的所有系统资源。
        br.close();
    }
}

StringReader

public class Test
{
    public static void main(String[] args) throws IOException
    {
        StringReader sr = new StringReader("aHello WorldHelloaabcdefghijklmnopqrstuvwxyzabcdefghijklmHelloHello World");
        //markSupported() boolean 判断此流是否支持 mark() 操作以及支持哪一项操作。
        System.out.println("markSupported():" + sr.markSupported());
        //ready() boolean 判断此流是否已经准备好用于读取。
        System.out.println("ready():" + sr.ready());
        //mark(int readAheadLimit) void 标记流中的当前位置。
        sr.mark(0);
        //read() int 读取单个字符。
        System.out.println("read():" + sr.read());
        char[] chars1 = new char[26];
        //read(char[] cbuf) int 将字符读入数组。
        sr.read(chars1);
        System.out.println("read(char[] cbuf):" + new String(chars1));
        char[] chars2 = new char[26];
        //read(char[] cbuf, int off, int len) int 将字符读入数组的某一部分。
        sr.read(chars2, 0, 13);
        System.out.println("read(char[] cbuf, int off, int len):" + new String(chars2));
        //reset()  void 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        sr.reset();
        //skip(long ns) long 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
        sr.skip(1);
        //close() void 关闭该流并释放与之关联的所有系统资源。
        sr.close();
    }
}

PipedReader与PipedWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        PipedReader pr = new PipedReader();
        PipedWriter pw = new PipedWriter();

        pr.connect(pw);

        ReaderThread rt = new ReaderThread(pr);
        WriterThread wt = new WriterThread(pw);

        new Thread(rt).start();  
        new Thread(wt).start();  
    }

}

class ReaderThread implements Runnable
{
    private PipedReader pr;

    public ReaderThread(PipedReader pr)
    {
        this.pr = pr;
    }

    public void run()
    {
        try  
        {  
            System.out.println("PipedReader:读取前没有数据,阻塞中...等待数据传过来再输出到控制台...");
            char[] chars1 = new char[26];
            //read(byte[] b) int 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
            pr.read(chars1);
            //ready() boolean 判断此流是否已经准备好用于读取。
            System.out.println("ready():" + pr.ready());
            System.out.println("PipedReader:读取数据成功,阻塞解除...");
            System.out.println(new String(chars1));  //将读取的数据流用字符串以字符串打印出来  
            //read() int 读取此传送流中的下一个数据字符。
            System.out.println(pr.read());
            char[] chars2 = new char[26];
            //read(char[] cbuf, int off, int len) int 将此传送流中最多 len 个数据字符读入字符数组。
            pr.read(chars2, 0, 14);
            System.out.println(new String(chars2));
            //markSupported() boolean 判断此流是否支持 mark()操作
            System.out.println(pr.markSupported());
            //close() int 关闭此管道输入流并释放与该流相关的所有系统资源。
            pr.close();       
        }  
        catch(Exception e)  
        {  
            throw new RuntimeException("PipedReader:管道读取流失败!");
        }     
    }
}

class WriterThread implements Runnable
{

    private PipedWriter pw;

    public WriterThread(PipedWriter pw)
    {
        this.pw = pw;
    }

    @Override
    public void run()
    {
        try  
        {
            System.out.println("PipedWriter:开始将数据写入");
            char[] chars1 = new char[26];
            for(int i = 0;i < chars1.length;i++)
            {
                chars1[i] = (char) ('A' + i%26);
            }
            //write(char[] cbuf) void 写入字符数组。 
            pw.write(chars1);
            //write(int c) void 将指定的 char 写入管道输出流。
            pw.write(97); 
            //write(char[] cbuf, int off, int len) int 将 len 将 len 字符从指定初始偏移量为 off 的字符数组写入到此管道输出流。
            pw.write(chars1, 0, 13);
            //flush() void 刷新此输出流并强制写出所有缓冲的输出字符。
            pw.flush();
            //append(char c) Writer 将指定字符添加到此 writer。 
            pw.append('b');
            //append(CharSequence csq) Writer 将指定字符序列添加到此 writer。 
            pw.append("Hello World");
            //append(CharSequence csq,int start,int end) Writer 将指定字符序列的子序列添加到此 writer.Appendable。 
            pw.append("Hello World", 0, 5);
            Thread.sleep(5000);
            //close() void 关闭此管道输出流并释放与此流相关的所有系统资源。
            pw.close();
        }  
        catch(Exception e)  
        {  
            throw new RuntimeException("PipedWriter:WriteThread写入失败...");  
        }  
    }
}

StringWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        StringWriter sw = new StringWriter();
        //append(char c) StringWriter 将指定字符添加到此 writer。
        sw.append('a');
        //append(CharSequence csq) StringWriter 将指定的字符序列添加到此 writer。
        sw.append("Hello World");
        //append(CharSequence csq, int start, int end) StringWriter 将指定字符序列的子序列添加到此 writer。
        sw.append("Hello World", 0, 5);
        //write(int c) void 写入单个字符。
        sw.write(97);
        char[] chars1 = new char[26];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        //write(char[] cbuf) void 写入字符数组。 
        sw.write(chars1);
        //write(char[] cbuf, int off,int len) void 写入字符数组的某一部分。
        sw.write(chars1, 0, 13);
        //write(char[] cbuf, int off, int len) void 写入字符数组的某一部分。
        sw.write("Hello World", 0, 5);
        //write(String str) void 写入一个字符串。
        sw.write("Hello World");
        //flush() void  刷新该流的缓冲。
        sw.flush();
        //close() void 关闭 StringWriter 无效。
        sw.close();
        //toString() String 以字符串的形式返回该缓冲区的当前值。
        System.out.println(sw.toString());
        //getBuffer() StringBuffer 返回该字符串缓冲区本身。
        System.out.println(sw.getBuffer());

    }
}

OutputStreamWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\Test9.txt"),"UTF-8");
        //write(int c) void 写入单个字符。
        osw.write(97);
        char[] chars1 = new char[26];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        //append(char c) StringWriter 将指定字符添加到此 writer。
        osw.append('a');
        //append(CharSequence csq) StringWriter 将指定的字符序列添加到此 writer。
        osw.append("Hello World");
        //append(CharSequence csq, int start, int end) StringWriter 将指定字符序列的子序列添加到此 writer。
        osw.append("Hello World", 0, 5);
        //write(char[] cbuf) void 写入字符数组。 
        osw.write(chars1);
        //write(char[] cbuf, int off,int len) void 写入字符数组的某一部分。
        osw.write(chars1, 0, 13);
        //write(char[] cbuf, int off, int len) void 写入字符数组的某一部分。
        osw.write("Hello World", 0, 5);
        //write(String str) void 写入一个字符串。
        osw.write("你好，世界");
        //getEncoding() String 返回此流使用的字符编码的名称。
        System.out.println("getEncoding():" + osw.getEncoding());
        //flush() void 刷新该流的缓冲。
        osw.flush();
        //close() void 关闭此流，但要先刷新它。
        osw.close();
    }
}

FileWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fw = new FileWriter("E:\\Test10.txt");
        //write(int c) void 写入单个字符。
        fw.write(97);
        char[] chars1 = new char[26];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        //append(char c) StringWriter 将指定字符添加到此 writer。
        fw.append('a');
        //append(CharSequence csq) StringWriter 将指定的字符序列添加到此 writer。
        fw.append("Hello World");
        //append(CharSequence csq, int start, int end) StringWriter 将指定字符序列的子序列添加到此 writer。
        fw.append("Hello World", 0, 5);
        //write(char[] cbuf) void 写入字符数组。 
        fw.write(chars1);
        //write(char[] cbuf, int off,int len) void 写入字符数组的某一部分。
        fw.write(chars1, 0, 13);
        //write(char[] cbuf, int off, int len) void 写入字符数组的某一部分。
        fw.write("Hello World", 0, 5);
        //write(String str) void 写入一个字符串。
        fw.write("你好，世界");
        //getEncoding() String 返回此流使用的字符编码的名称。
        System.out.println("getEncoding():" + fw.getEncoding());
        //flush() void 刷新该流的缓冲。
        fw.flush();
        //close() void 关闭此流，但要先刷新它。
        fw.close();
    }
}

CharArrayWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        CharArrayWriter caw = new CharArrayWriter(1024);
        //write(int c) void 写入单个字符。
        caw.write(97);
        char[] chars1 = new char[26];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        //append(char c) StringWriter 将指定字符添加到此 writer。
        caw.append('a');
        //append(CharSequence csq) StringWriter 将指定的字符序列添加到此 writer。
        caw.append("Hello World");
        //append(CharSequence csq, int start, int end) StringWriter 将指定字符序列的子序列添加到此 writer。
        caw.append("Hello World", 0, 5);
        //write(char[] cbuf) void 写入字符数组。 
        caw.write(chars1);
        //write(char[] cbuf, int off,int len) void 写入字符数组的某一部分。
        caw.write(chars1, 0, 13);
        //write(char[] cbuf, int off, int len) void 写入字符数组的某一部分。
        caw.write("Hello World", 0, 5);
        //write(String str) void 写入一个字符串。
        caw.write("你好，世界");
        //toCharArray() char[] 返回输入数据的副本。
        System.out.println("toCharArray():" + new String(caw.toCharArray()));
        FileWriter fw = new FileWriter("E:\\Test11.txt");
        //writeTo(Writer out) void 将缓冲区的内容写入另一个字符流。
        caw.writeTo(fw);
        fw.flush();
        //size() int 返回缓冲区的当前大小。
        System.out.println("size():" + caw.size());
        //reset() void 重置该缓冲区，以便再次使用它而无需丢弃已分配的缓冲区。
        caw.reset();
        //flush() void 刷新该流的缓冲。
        caw.flush();
        //close() void 关闭此流，但要先刷新它。
        caw.close();
    }
}

BufferedWriter

public class Test
{
    public static void main(String[] args) throws IOException
    {
        CharArrayWriter caw = new CharArrayWriter(1024);
        BufferedWriter bw = new BufferedWriter(caw, 2048);
        //write(int c) void 写入单个字符。
        bw.write(97);
        char[] chars1 = new char[26];
        for(int i = 0;i < chars1.length;i++)
        {
            chars1[i] = (char) ('a' + i%26);
        }
        //append(char c) StringWriter 将指定字符添加到此 writer。
        bw.append('a');
        //append(CharSequence csq) StringWriter 将指定的字符序列添加到此 writer。
        bw.append("Hello World");
        //append(CharSequence csq, int start, int end) StringWriter 将指定字符序列的子序列添加到此 writer。
        bw.append("Hello World", 0, 5);
        //write(char[] cbuf) void 写入字符数组。 
        bw.write(chars1);
        //write(char[] cbuf, int off,int len) void 写入字符数组的某一部分。
        bw.write(chars1, 0, 13);
        //write(char[] cbuf, int off, int len) void 写入字符数组的某一部分。
        bw.write("Hello World", 0, 5);
        //write(String str) void 写入一个字符串。
        bw.write("你好，世界");
        //newLine() void 写入一个行分隔符。
        bw.newLine();
        //flush() void 刷新该流的缓冲。
        bw.flush();
        //close() void 关闭此流，但要先刷新它。
        bw.close();
    }
}