Java8 I/O源码-Reader与Writer

来源：互联网发布：python网络编程 amazon 编辑：程序博客网时间：2024/05/22 00:31

字节输入流的学习告一段落了，接下来的一段时间学习字符输入流。本文学习字符输入流的抽象类Reader与和字符输出流的抽象类Writer。

Reader

Reader是字符输入流的抽象类。子类必须实现的方法只有read(char[], int, int) 和close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

下面学习下Reader.java的源码。

public abstract class Reader implements Readable, Closeable {    protected Object lock;//用于同步针对此流的操作的对象。    /**     * 构造函数之一     * 创建一个新的字符流Reader，其重要部分将同步其自身。     */    protected Reader() {        this.lock = this;    }    /**     * 构造函数之一     * 创建一个新的字符流reader，其重要部分将同步给定的对象lock     */    protected Reader(Object lock) {        if (lock == null) {            throw new NullPointerException();        }        this.lock = lock;    }    /**     * 试图将字符读入指定的字符缓冲区。     * 缓冲区可照原样用作字符的存储库：所做的唯一改变是put操作的结果。不对缓冲区执行翻转或重绕操作。     * 将输入流管道中的target.length个字节读取到指定的缓存字符数组target中、返回实际存放到target中的字符数。      */    public int read(java.nio.CharBuffer target) throws IOException {        //获取此缓冲区中的剩余元素数        int len = target.remaining();        char[] cbuf = new char[len];        //试图将输入流中的len个字符读入cbuf，返回实际读取的字节数n        int n = read(cbuf, 0, len);        //如果实际读到字符的个数大于0        if (n > 0)            //将实际读取到的n个字符存入缓冲区            target.put(cbuf, 0, n);        //返回实际读取的字符数        return n;    }    /**     * 从输入流中读取单个字符。     */    public int read() throws IOException {        char cb[] = new char[1];        if (read(cb, 0, 1) == -1)            return -1;        else            return cb[0];    }    /**     * 从输入流中读取一定数量的字符并把它们保存到缓冲数组b中。返回读取的字节数。     */    public int read(char cbuf[]) throws IOException {        return read(cbuf, 0, cbuf.length);    }    /**     * 从输入流中，读取最多len个字节到字符数组中。     *     * @param   cbuf  存储读入数据的字节数组。     * @param   off   起始偏移量     * @param   len   读取的最大字节数。     * @return  读入字节数组的总字节数，如果由于已到达流末尾而不再有数据，则返回-1。     */    abstract public int read(char cbuf[], int off, int len) throws IOException;    /** 存放被跳过字节的缓冲区的最大值 */    private static final int maxSkipBufferSize = 8192;    /** 存放被跳过字节的缓冲区 */    private char skipBuffer[] = null;    /**     * 跳过字符     *     * @param  n  要跳过的字符数     * @return    实际跳过的字符数     *     */    public long skip(long n) throws IOException {        //如果n为负数，抛出异常        if (n < 0L)            throw new IllegalArgumentException("skip value is negative");        //不允许n大于maxSkipBufferSize        int nn = (int) Math.min(n, maxSkipBufferSize);        synchronized (lock) {            //如果现有缓冲区为null或者大小小于nn，就新建一个大小为nn的缓冲区            if ((skipBuffer == null) || (skipBuffer.length < nn))                skipBuffer = new char[nn];            long r = n;            //循环跳过输入流中字符，一次尝试跳过nn个字符，直到到达输入流末尾或者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;    }    /**     * 判断此流是否支持mark()操作。默认实现始终返回 false。     */    public boolean markSupported() {        return false;    }    /**     * 标记流中的当前位置。与reset()配合使用。reset()的后续调用将尝试将该流重新定位到此点。     * 该方法需要子类重写     */    public void mark(int readAheadLimit) throws IOException {        throw new IOException("mark() not supported");    }    /**     * 将流的读取位置重置到最后一次调用mark方法时的位置     * 该方法需要子类重写     */    public void reset() throws IOException {        throw new IOException("reset() not supported");    }    /**     * 关闭该流并释放与之关联的所有资源。     */     abstract public void close() throws IOException;}

Writer

Writer是字符输出流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

下面学习下Writer的源码。

public abstract class Writer implements Appendable, Closeable, Flushable {    /**     * 字符缓存数组。     * 用于临时存放要写入字符输出流中的字符     */    private char[] writeBuffer;    /**     * 字符缓存数组的默认大小。     */    private static final int WRITE_BUFFER_SIZE = 1024;    /**     * 用于同步针对此流的操作的对象。     */    protected Object lock;    /**     * 构造方法     * 创建一个新的字符流writer，其关键部分将同步其自身。     */    protected Writer() {        this.lock = this;    }    /**     * 构造方法     * 建一个新的字符流writer，其关键部分将同步给定的对象。     */    protected Writer(Object lock) {        if (lock == null) {            throw new NullPointerException();        }        this.lock = lock;    }    /**     * 写入单个字符。     * 要写入的字符包含在给定整数值的16个低位中，16高位被忽略。     */    public void write(int c) throws IOException {        synchronized (lock) {            if (writeBuffer == null){                writeBuffer = new char[WRITE_BUFFER_SIZE];            }            //char为16位。所以要写入的字符包含在给定整数值的16个低位中，16高位被忽略。            writeBuffer[0] = (char) c;            write(writeBuffer, 0, 1);        }    }    /**     * 将一个字符数组写入到writerBuffer中      */    public void write(char cbuf[]) throws IOException {        write(cbuf, 0, cbuf.length);    }    /**     * 试图将字符数组中从off开始的len个字符写入输出流中。     * 尽量写入len个字符，但写入的字节数可能少于len个，也可能为零。     */    abstract public void write(char cbuf[], int off, int len) throws IOException;    /**     * 写入字符串     */    public void write(String str) throws IOException {        write(str, 0, str.length());    }    /**     * 试图将字符串中从off开始的len个字符写入输出流中。     * 尽量写入len个字符，但写入的字节数可能少于len个，也可能为零。     *     * @param  试图写入的字符串     * @param  off 偏移量     * @param  试图写入的长度     * @throws  IndexOutOfBoundsException  如果off或len为负，或者off+len 为负或大于给定字符串的长度     */    public void write(String str, int off, int len) throws IOException {        synchronized (lock) {            char cbuf[];            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];            }            //将字符串中从off开始到off+len的字符复制到cbuf中            str.getChars(off, (off + len), cbuf, 0);            write(cbuf, 0, len);        }    }    /**     * 添加字符序列     */    public Writer append(CharSequence csq) throws IOException {        if (csq == null)            write("null");        else            write(csq.toString());        return this;    }    /**     * 添加字符序列的一部分     */    public Writer append(CharSequence csq, int start, int end) throws IOException {        CharSequence cs = (csq == null ? "null" : csq);        write(cs.subSequence(start, end).toString());        return this;    }    /**     * 添加指定字符     */    public Writer append(char c) throws IOException {        write(c);        return this;    }    /**     * 刷新该流的缓冲。     */    abstract public void flush() throws IOException;    /**     * 关闭此流，但要先刷新它。     */    abstract public void close() throws IOException;}

总结

Reader是字符输入流的抽象类。子类必须实现的方法只有read(char[], int, int) 和close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。如重写read方法提供更高的效率；重写mark/set方法提供标记功能。
Writer是字符输出流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

Reader与InputStream区别

操作对象的不同。字节流操作字节、字符操作字符。
实现的接口不同。Reader比InputStream多实现了一个Readable接口，用于提供一个可以将字符写入到指定缓存数组的方法。
close方法不同。Reader的close方法是抽象的、子类必须重写。 InputStream的close方法则不是抽象的。

Writer与OutputStream区别

操作对象的不同。字节流操作字节、字符操作字符。
实现的接口不同。Writer相比与OutputStream多实现了一个Appendable接口、用于提供几个向此流中追加字符的方法。
close、flush方法不同。Writer的close、flush方法都是抽象的，而OutputStream则不是。

关于Reader与Writer就讲到这里，想了解更多内容请参考

Java8 I/O源码系列专栏-目录
Java8 I/O源码-InputStream
Java8 I/O源码-OutputStream

版权声明作者：潘威威

原文地址：CSDN博客-潘威威的博客-http://blog.csdn.net/panweiwei1994/article/details/78312152

本文版权归作者所有，欢迎转载。转载时请在文章明显位置给出原文作者名字（潘威威）及原文链接。请勿将本文用于任何商业用途。

阅读全文

0 0