java IO笔记(CharArrayReader/CharArrayWriter)

来源：互联网发布：js li默认选中样式编辑：程序博客网时间：2024/06/05 15:28

本篇要讲述的是CharArrayReader和CharArrayWriter两个类。它们两个同之前的ByteArrayInputStream和ByteArrayOutputStream和相似，两者的主要区别是前者是基于字符数组来工作的，后者是基于字节数组来创建的。

下面先说说CharArrayReader，先附上源码：

package java.io;public class CharArrayReader extends Reader {    //用于存储从流中读取的数据    protected char buf[];    //下一个读取的字符位置    protected int pos;    //被标记的字符位置，reset时pos回到此处    protected int markedPos = 0;    //字符数组的长度    protected int count;    //初始化传入一个字符数组    public CharArrayReader(char buf[]) {        this.buf = buf;        this.pos = 0;        this.count = buf.length;    }    //初始化传入一个字符数组，offset为开始读取的索引，length是读取的长度    public CharArrayReader(char buf[], int offset, int length) {        if ((offset < 0) || (offset > buf.length) || (length < 0) ||            ((offset + length) < 0)) {            throw new IllegalArgumentException();        }        this.buf = buf;        this.pos = offset;        this.count = Math.min(offset + length, buf.length);        this.markedPos = offset;    }    //判断流是否处于打开状态,因为当执行close后，buf会被置为null    private void ensureOpen() throws IOException {        if (buf == null)            throw new IOException("Stream closed");    }    //按每个字符读取，读取时首先判断流是否处于打开状态,如果下一个读取的索引位置超出数据长度，则返回-1，否则回对应的字符。    public int read() throws IOException {        synchronized (lock) {            ensureOpen();            if (pos >= count)                return -1;            else                return buf[pos++];        }    }        //该方法是按照所传入的数组来进行读取，off为开始读取的位置，len为读取的长度    public int read(char b[], int off, int len) throws IOException {        synchronized (lock) {            ensureOpen();            if ((off < 0) || (off > b.length) || (len < 0) ||                ((off + len) > b.length) || ((off + len) < 0)) {                throw new IndexOutOfBoundsException();            } else if (len == 0) {                return 0;            }            if (pos >= count) {                return -1;            }            if (pos + len > count) {                len = count - pos;            }            if (len <= 0) {                return 0;            }            System.arraycopy(buf, pos, b, off, len);            pos += len;            return len;        }    }    //跳过n字符再进行读取    public long skip(long n) throws IOException {        synchronized (lock) {            ensureOpen();            if (pos + n > count) {                n = count - pos;            }            if (n < 0) {                return 0;            }            pos += n;            return n;        }    }    //该方法用于判断是否还有刻度数据    public boolean ready() throws IOException {        synchronized (lock) {            ensureOpen();            return (count - pos) > 0;        }    }    //判断是否支持标记功能，一直返回true    public boolean markSupported() {        return true;    }    //标记功能，将当前pos值做为标记值，传入的参数无意义    public void mark(int readAheadLimit) throws IOException {        synchronized (lock) {            ensureOpen();            markedPos = pos;        }    }        //重置当前pos值，使其返回标记的位置，mark值如果没有重置过，默认为0    public void reset() throws IOException {        synchronized (lock) {            ensureOpen();            pos = markedPos;        }    }    //流关闭时，将数据缓存置为null    public void close() {        buf = null;    }}

从上可以看出，CharArrayReader在关闭流后，无法执行其中方法，并且其中的缓存数据将会被清空，这点和ByteArrayInputStream有着明显的区别。

下面讲讲CharArrayWriter，先贴上源码：

package java.io;import java.util.Arrays;publicclass CharArrayWriter extends Writer {    //用于存放写入数据的临时缓存    protected char buf[];    //数据长度    protected int count;        //不带参的构造函数，默认缓存空间为32字节大小    public CharArrayWriter() {        this(32);    }    //带一个参数的构造函数，传入参数为缓存的空间大小    public CharArrayWriter(int initialSize) {        if (initialSize < 0) {            throw new IllegalArgumentException("Negative initial size: "                                               + initialSize);        }        buf = new char[initialSize];    }    //带一个参数的wirte方法，传入参数为要写入的字符，如果缓存空间不足时，缓存区会自动扩容，空间翻倍。    public void write(int c) {        synchronized (lock) {            int newcount = count + 1;            if (newcount > buf.length) {                buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));            }            buf[count] = (char)c;            count = newcount;        }    }    //第一个参数是要写入的字符数组，第二个参数为开始写入的位置，第三个参数是写入的长度    public void write(char c[], int off, int len) {        if ((off < 0) || (off > c.length) || (len < 0) ||            ((off + len) > c.length) || ((off + len) < 0)) {            throw new IndexOutOfBoundsException();        } else if (len == 0) {            return;        }        synchronized (lock) {            int newcount = count + len;            if (newcount > buf.length) {                buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));            }            System.arraycopy(c, off, buf, count, len);            count = newcount;        }    }    //第一个参数是要写入的字符串，第二个参数为开始写入的位置，第三个参数是写入的长度    public void write(String str, int off, int len) {        synchronized (lock) {            int newcount = count + len;            if (newcount > buf.length) {                buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));            }            str.getChars(off, off + len, buf, count);            count = newcount;        }    }    //该方法是将缓存中的数据写人另一个流中    public void writeTo(Writer out) throws IOException {        synchronized (lock) {            out.write(buf, 0, count);        }    }    //该方法可以向流中写入传入的字符序列    public CharArrayWriter append(CharSequence csq) {        String s = (csq == null ? "null" : csq.toString());        write(s, 0, s.length());        return this;    }    //该方法可以向流中写入字符序列，第二和第三个参数决定了写入的起点和终点    public CharArrayWriter append(CharSequence csq, int start, int end) {        String s = (csq == null ? "null" : csq).subSequence(start, end).toString();        write(s, 0, s.length());        return this;    }    //该方法可以向流中写入传入的字符，与write的区别是该方法返回了流对象    public CharArrayWriter append(char c) {        write(c);        return this;    }    //重置读取位置，将count置为0    public void reset() {        count = 0;    }    //将流中缓存区的数据以char数组的形式返回    public char toCharArray()[] {        synchronized (lock) {            return Arrays.copyOf(buf, count);        }    }    //返回数据的大小    public int size() {        return count;    }    //将流中数据已字符串的形式返回    public String toString() {        synchronized (lock) {            return new String(buf, 0, count);        }    }    //刷新流    public void flush() { }    //关闭流    public void close() { }}

以上为本篇的内容。

阅读全文

0 0