在上一篇文章中，梳理了IO的字节流，现在接着梳理字符流，如果文中有任何不对的地方，麻烦帮忙指出~

在《Java编程思想》中有提及：当我们初次看见Reader和Writer时，可能会认为这两个类是用来替换InputStream和OutputStream的，但实际上并不是。InputStream和OutputStream在以面向字节形式的IO中仍可以提供极有价值的功能，而Reader和Writer则提供兼容Unicode与面向字符的IO功能。

Reader&writer

在大体上，所有的字节流IO类都有对应的Reader和Writer，如下图：

Reader&Writer.png

可以看到，图中的类都属于Reader和Writer的子类，这两个类是抽象类，代码如下：

/**
**Reader&Writer类示例
**/
public abstract class Reader implements Readable, Closeable {
    protect Object lock;
/** field and method **/
}
public abstract class Writer implements Appendable, Closeable, Flushable {
    protected Object lock;
/** field and method **/
}

在上面的代码中，特意写了lock字段，用这个字段来同步类内部的操作，在字节IO类也有类似的同步操作，只是使用的是Synchronized方法。下面来具体看一下这些类。

CharArrayReader&CharArrayWriter

类似于ByteArrayInputStream和ByteArrayOutputStream，CharArrayReader/Writer处理的是内存中的字符串，在类的内部使用了一个缓存数组char[] buf，将读取的的字符转换成字符流存储在这个buf中，需要使用的时候，将这个字符流输出或传给其他字符流使用。如下所示：

/**
**CharArrayReader&CharArrayWriter示例
**/
public class CharArrayDemo {
    public static void main(String[] arg0) throws IOException{
        String test = "test CharArrayReader";
        CharArrayReader charArrayReader = new CharArrayReader(test.toCharArray());
        char[] buf = new char[1024];
        int len = charArrayReader.read(buf);
        System.out.println(new String(buf,0,len) );
        CharArrayWriter charArrayWriter = new CharArrayWriter();
        charArrayWriter.write(buf, 0, len);
        char[] writer = charArrayWriter.toCharArray();
        System.out.println(writer);
    }
}
输出：
test CharArrayReader
test CharArrayReader

在上面的代码中，CharArrayReader的作用是读取内存中test变量值，使用buf数组来测试读取的内容的正确性，然而在CharArrayWriter中则是将流中的数据输出到数组中，使用write()方法将数据写入流中，使用toCharArray()方法输出到定义的char[]数组中。当然他们都可以当做参数传给其他流进行操作。

FileReader&FileWriter

这两个类是InputStreamReader和OutputStreamWriter的子类，从名字就可以看出操作的是字符类文件，类似于FileInputStream和FileOutputStream,只是在这两个类中，使用的char而不是byte，代码如下：

/**
**FileReader&FileWriter示例
**/
public class FileDemo {
    public static void main(String[] arg0) throws IOException{
        FileReader fileReader = new FileReader("/test/test.txt");
        FileWriter fileWriter = new FileWriter("/test/test1.txt");
        int len1 = 0;
        char[] buff = new char[1024];
        while((len1 = fileReader.read(buff))!=-1){
            fileWriter.write(buff);
        }
        fileWriter.flush();
    }
}

在代码运行之后，如果不存在test1.txt文件，会在对应的位置创建一个，如果不想要覆盖原有文件，FileWriter提供了相应的构造函数FileWriter(String fileName, boolean append)，这里需要注意的是FileWriter存在一个从父类OutputStream中继承下来的flush()方法，调用这个方法会将缓存中的内容刷新到目标文件或流中，当然，调用close()时会自动刷新。

ps:InputStreamReader和OutputStreamWriter是Reader和Writer的子类，它们提供了一系列的构造方法将一个InputStream或者OutputStream转换成Reader或Writer，打通了两者的转化。两者的内部都存在关键字段StreamEncoder se或StreamDecoder sd，使用这两个字段来处理功能，详情可以翻看一下源码。

BufferedReader&BufferedWriter

在之前的代码中都使用了一个数组char[] buff来缓存，但是在这里，BufferedReader和BufferedWriter内部就有维护这样一个数组char cb[]用来缓存字符，相对于没有使用缓存机制的Reader和Writer来说会更高效些，因为不是每次都直接使用IO来操作了，如下所示：

/**
**BufferReader&BufferWriter示例
**/
public class BufferDemo {
    public static void main(String[] arg0) throws IOException{
        FileReader fileReader = new FileReader("/test/test.txt");
        BufferedReader bufferReader = new BufferedReader(fileReader);   
        FileWriter fileWriter = new FileWriter("/test/test1.txt",true);
        BufferedWriter bufferWriter = new BufferedWriter(fileWriter);
        
        String mesg = null;
        while((mesg =bufferReader.readLine())!=null){
            bufferWriter.write(mesg+"\n");      
        }
        bufferWriter.flush();   
    }
}

在上面代码中，并没有像之前的代码一样，自己定义了buff缓存，但是使用这个流就可以实现这个功能，和FileReader&FileWriter之前的代码相比，并没有特别的优势，需要提及的是，在这两个类中都存在一个字段defaultCharBufferSize = 8192，说明缓存数组就只能存放这么长的字符。
在这里顺道说一下LineNumberReader，这个类在BufferReader的基础上，新增了四个字段，了解一下它新增的功能:lineNumber的get和set。

PipedReader&PipedWriter

类似于PipedInputStream&PipedOutputStream，PipedReader&PipedWriter也是用来处理线程间的通信的，不过这两个类使用的是字符而不是字节，代码如下：

/**
**PipedReader&PipedWriter示例
**/
public class PipedDemo {
    public static void main(String[] arg0) throws IOException{
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader);
        new Thread(new Product(writer)).start();
        new Thread(new Consumer(reader)).start();
    }
}
class Product implements Runnable{
    PipedWriter writer;
    public Product(PipedWriter writer){
        this.writer = writer;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        String test = "hello world";
        try {
            writer.write(test);
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}
class Consumer implements Runnable{
    PipedReader reader;
    public Consumer(PipedReader reader){
        this.reader = reader;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        BufferedReader br = new BufferedReader(reader);
        String mesg = null; 
        try {
            while((mesg = br.readLine())!=null){
                System.out.println(mesg+"\n");
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}
输出：
hello world

从上面看到，基本上和使用字节流没有太大的变化，不过如果是字符的话，还是使用字符流比较好。

StringReader&StringWriter

这两个类可以直接操作String对象，在构造函数中需要传入一个String对象，而对于StringWriter，我们可以将流中的字符串以字符的方式返回。如下：

/**
**StringReader&StringWriter示例
**/
public class StringDemo {
    public static void main(String[] arg0) throws IOException{
        String test = "StringReader test";
        StringReader strReader = new StringReader(test);
        BufferedReader bufReader = new BufferedReader(strReader);
        System.out.println(bufReader.readLine());
        
        StringWriter writer = new StringWriter();
        writer.write(" StringWriter test");
        writer.flush();
        System.out.println(writer.toString());
    }
}
输出：
StringReader test
 StringWriter test

对于其他的几个字符流如PushbackReader和PrintWriter，这里就不做其他实例了，大体上和PushbackInputStream与PrintOutputStream类似，如果想了解更多可以看下源码再自己敲一点。下面说一下这个特殊的类RandomAccessFile。

RandomAccessFile

这个类并不是InputStream或者OutputStream、Reader、Writer下的子类，它独立存在java.io包下，但是能处理File文件，《Java编程思想》中有写到：适用于由大小已知的记录组成的文件。就像是个DataInputStram或DataOutputStream,但是和两者并没有关系，在源码中可以看到，它只实现了几个接口，并没有继承关系，而且内部的类大部分都使用的native方法。在这个类中有两个方法需要特别记住的是seek(long point)和long getFilePointer()，通过这两个方法能灵活的对文件进行操作，类似于断点下载功能大体上就可以这样实现。下面看看Demo：

/**
**RandomAccessFile 示例
**/
public class RandomAccessFileDemo {

    public static void main(String[] arg0) throws IOException{
        File file = new File("/test/test.txt");
        //存在四中模式，即，O_RDONLY r 只读、O_RDWR rw 读写、  O_SYNC rws、  O_DSYNC rwd
        RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
        String test = "abcdef\n";
        randomAccessFile.write(test.getBytes());
//      System.out.println(randomAccessFile.readChar());
        randomAccessFile.seek(0);
        byte[] buf = new byte[1024];
        int len =0;
        while((len = randomAccessFile.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        System.out.println("----分隔---");

        randomAccessFile.seek(randomAccessFile.length());
        randomAccessFile.write("asdfgh\n".getBytes());
        
        randomAccessFile.seek(0);
        len =0;
        buf = new byte[1024];
        while((len = randomAccessFile.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
    }
}
输出：
abcdef

----分隔---
abcdef
asdfgh

从上面的代码就可以看到RandomAccessFile使用的一个大概，另外它还提供了一系列的write和read方法，能满足各种需求。如果感兴趣可以写个demo试试。

可以看到，在上面列举出来的例子都是很简单的例子，对于一些细节，还是需要认真看源码研究，并动手实践的，而不是看看小例子就能都了解知道，如果有时间的话，还请多多动手实践整理。

参考：
《Java编程思想》
《Java程序设计语言》
其实还看了很多文章，这里就没有一一列举了