java IO笔记（Reader/Writer）

本篇讲述的是java io中的reader和writer。跟之前讲述的InputStream和OutputStream一样为io流中的抽象父类之一，不过Reader和Writer的操作对象不再是字节而是字符了。下面也不多说，贴上源码来加深我们的理解。

Reader.java

package java.io;

public abstract class Reader implements Readable, Closeable {

    /**
     * 声明一个Object对象，为后续方法进行同步操作时，提供同步锁
     */
    protected Object lock;

    /**
     * 一个不带参的构造方法，并将锁对象lock初始化为当前类
     */
    protected Reader() {
        this.lock = this;
    }

    /**
     *一个带一个参数的构造方法，传入一个Object对象，对传入参数进行安全监测后，将传入参数赋值给锁对象lock
     */
    protected Reader(Object lock) {
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
    }

    /**
     * 一个带一个参数的read方法，传入的参数为一个字符缓冲区对象，从流中读取字符数据放置与字符缓冲区中，最终返回实际存储到字符缓冲区的字符的数量
     */
    public int read(java.nio.CharBuffer target) throws IOException {
	//返回字符缓冲区中可以使用的元素数量，将其作为临时字符数组的长度
        int len = target.remaining();
	//创建一个字符数组，用于读取流中的数据
        char[] cbuf = new char[len];
        int n = read(cbuf, 0, len);
	//读取数据后，将字符数组中的数据全部置于字符缓冲区中
        if (n > 0)
            target.put(cbuf, 0, n);
        return n;
    }

    /**
     *一个不带参数的read方法，每次读取一个字符，如果没有成功读取到字符数据返回-1，否则返回读取到的字符
     */
    public int read() throws IOException {
        char cb[] = new char[1];
        if (read(cb, 0, 1) == -1)
            return -1;
        else
            return cb[0];
    }

    /**
     * 一个带一个参数的read方法，传入的参数为一个字符数组，从流中读取数据，并将数据存放入传入的字符数组中，最终返回成功读取到的字符数量
     */
    public int read(char cbuf[]) throws IOException {
        return read(cbuf, 0, cbuf.length);
    }

    /**
     *一个带三个参数的read方法，该方法为抽象方法，第一个参数为一个字符数组，第二个参数为数据存储开始的位置，第三个参数为数据存储使用的长度
     */
    abstract public int read(char cbuf[], int off, int len) throws IOException;

    /**
     *声明了一个静态常量，maxSkipBufferSize，将其赋值为8192，该值表明了最多能跳过的字符数
     */
    private static final int maxSkipBufferSize = 8192;

    /** 
     *声明了一个字符数组，该数组用于跳过阅读
     */
    private char skipBuffer[] = null;

    /**
     * 一个带一个参数的skip方法，参数为long型，表明要跳过的长度
     */
    public long skip(long n) throws IOException {
	//对传入参数进行安全监测，如果小于0，则抛出异常
        if (n < 0L)
            throw new IllegalArgumentException("skip value is negative");
	//确定跳过的字符数量，如果n没有超过最大限定的值，则跳过n个长度，如果大于最大值，则跳过最大值的长度（maxSkipBufferSize）
        int nn = (int) Math.min(n, maxSkipBufferSize);
	//如果skipbuffer为空或者其容量不足以满足跳跃的长度，则新建一个skipBuffer
        synchronized (lock) {
            if ((skipBuffer == null) || (skipBuffer.length < nn))
                skipBuffer = new char[nn];
            long r = n;
	//根据需要跳过的长度来进行读取，最终返回实际跳过的字符数量
            while (r > 0) {
                int nc = read(skipBuffer, 0, (int)Math.min(r, nn));
                if (nc == -1)
                    break;
                r -= nc;
            }
            return n - r;
        }
    }

    /**
     * 检测当前流是否可读，此处永远返回false
     */
    public boolean ready() throws IOException {
        return false;
    }

    /**
     * 检测当前流是否支持标记功能，此处永远返回false
     */
    public boolean markSupported() {
        return false;
    }

    /**
     *一个带一个参数的mark方法，传入的参数为标记的位置，用于在流中进行标记，一般与reset方法一起使用
     */
    public void mark(int readAheadLimit) throws IOException {
        throw new IOException("mark() not supported");
    }

    /**
     *一个不带参数的reset方法，将流的读取位置重置到被mark方法标记的位置
     */
    public void reset() throws IOException {
        throw new IOException("reset() not supported");
    }

    /**
     * close方法用于关闭流，是一个抽象方法
     */
     abstract public void close() throws IOException;

}

Writer.java

package java.io;

public abstract class Writer implements Appendable, Closeable, Flushable {

    /**
     * 声明了一个字符数组，用于存放需要写出的数据
     */
    private char[] writeBuffer;

    /**
     * 定义了静态常量值 WRITE_BUFFER_SIZE，该值为存放写出数据的字符数组的初始容量，初始容量为1024
     */
    private static final int WRITE_BUFFER_SIZE = 1024;

    /**
     * 声明一个Object对象，为后续方法进行同步操作时，提供同步锁
     */
    protected Object lock;

    /**
     * 一个不带参的构造方法，并将锁对象lock初始化为当前类
     */
    protected Writer() {
        this.lock = this;
    }

    /**
     * 一个带有一个参数的Writer对象，传入的参数为一个Object对象，并将该值赋值给锁对象lock
     */
    protected Writer(Object lock) {
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
    }

    /**
     * 带有一个参数的write方法，传入的是一个字符的int型值，每次写出一个字符
     */
    public void write(int c) throws IOException {
        synchronized (lock) {
            if (writeBuffer == null){
                writeBuffer = new char[WRITE_BUFFER_SIZE];
            }
            writeBuffer[0] = (char) c;
            write(writeBuffer, 0, 1);
        }
    }

    /**
     * 带有一个参数的write方法，传入的是一个字符型数组，将传入的数组中的内容一次写出
     */
    public void write(char cbuf[]) throws IOException {
        write(cbuf, 0, cbuf.length);
    }

    /**
     * 一个带有三个参数的write方法，第一个参数为一个字符型数组，其中存放着需要写出的数据，第二个参数为开始写出的位置，第三个参数为需要写出的长度
     *该方法为抽象方法
     */
    abstract public void write(char cbuf[], int off, int len) throws IOException;

    /**
     * 一个带有一个参数的write方法，该参数为一个要写出的字符串数据
     */
    public void write(String str) throws IOException {
        write(str, 0, str.length());
    }

    /**
     * 一个带有三个参数的write方法，第一个参数为要写出的字符串数据，第二个参数为开始写出的位置，第三个参数为需要写出的长度
     */
    public void write(String str, int off, int len) throws IOException {
        synchronized (lock) {
	//声明了一个字符数组
            char cbuf[];
	//如果writeBuffer没有创建过，则创建。如果写出长度<小于定义的初始容量，则wirteBuffer初始化容量为1024，如果大于，则用长度初始化其容量
            if (len <= WRITE_BUFFER_SIZE) {
                if (writeBuffer == null) {
                    writeBuffer = new char[WRITE_BUFFER_SIZE];
                }
                cbuf = writeBuffer;
            } else {    // Don't permanently allocate very large buffers.
                cbuf = new char[len];
            }
	//将需要写出的字符串转化为字符数组，写出
            str.getChars(off, (off + len), cbuf, 0);
            write(cbuf, 0, len);
        }
    }

    /**
     *一个带有一个参数的append方法，传入的参数为一个CharSequence类型的数据，经过安全监测后，将其转化为String型写出，最终返回当前Writer对象
     */
    public Writer append(CharSequence csq) throws IOException {
        if (csq == null)
            write("null");
        else
            write(csq.toString());
        return this;
    }

    /**
     * 一个带有三个参数的append方法，第一个参数是一个CharSequence类型的数据，第二个参数为要开始添加的位置，第三个参数为结束的位置
     */
    public Writer append(CharSequence csq, int start, int end) throws IOException {
	//对传入的csq先进行安全监测，通过后，根据起始位置和结束位置截取CharSequence数据，然后写出，最终返回当前Writer对象
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }

    /**
     * 一个带有一个参数的append方法，传入的参数为一个char型的数据，写入一个字符，最终返回当前Writer对象
     */
    public Writer append(char c) throws IOException {
        write(c);
        return this;
    }

    /**
     *一个抽象方法flush，该方法用于将缓存中的写入数据写出值目的处
     */
    abstract public void flush() throws IOException;

    /**
     * 关闭流
     */
    abstract public void close() throws IOException;

}

经过上面的源码可以看出，Reader/Writer和InputStream/OutputStream是十分相死的。但是也有一定的区别，最本质的区别就是前者是对字符进行操作，后者是对字节进行操作。并且两者间有些同名方法关于是否是抽象化方法略有不同。

以上为本篇内容。