Java IO - CharArrayReader&CharArrayWriter

基本概念

• CharArrayReader：此类实现一个可用作字符输入流的字符缓冲区。

• CharArrayWriter：此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。 在此类上调用 close() 无效，并且在关闭该流后可以调用此类中的各个方法，而不会产生任何 IOException。

-继承结构：分别继承了 Reader/Writer

---

源码分析

1.CharArrayReader

类结构结果图，通过与 ByteArrayInputStream 进行对比，发现 CharArrayReader 多了
ersureOpen()，ready() 少了一个 available()，且 ready 和 available 作用相似，通过下面的源码分析会发现二者的实现原理一模一样。

成员变量

//缓冲数组
protected char buf[];

//索引位置，表示当前读取的位置
protected int pos;

//标记位，只能标记当前读取的位置
protected int markedPos = 0;

//要读取的字符数组的长度
protected int count;

构造函数，结合成员变量的注释一目了然

public CharArrayReader(char buf[]) {
    this.buf = buf;
    this.pos = 0;
    this.count = buf.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;
}

先来看看多出来的 ensureOpen() 方法

//判断缓冲数组是否为空，作用就是字面上的意思确保字符流打开不为空，否则抛出异常
private void ensureOpen() throws IOException {
    if (buf == null){
        throw new IOException("Stream closed");
    }   
}

read 操作，这里实现了 Reader 中定义的抽象 read 方法，原理与字节数组输入流一模一样。

//读取单个字符
public int read() throws IOException {
    synchronized (lock) {
        ensureOpen();
        if (pos >= count)
            return -1;
        else
            return buf[pos++];
    }
}

//将字符读入数组的某一部分
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;
    }
}

skip 方法

表示要跳跃字符数量，通过改变数组的索引位置实现
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;
    }
}

mark/reset 方法

//只能标记当前的读取位置，与参数值无关
public void mark(int readAheadLimit) throws IOException {
    synchronized (lock) {
        ensureOpen();
        markedPos = pos;
    }
}

public void reset() throws IOException {
    synchronized (lock) {
        ensureOpen();
        pos = markedPos;
    }
}

剩下的方法，只贴出源码，不做分析

public boolean markSupported() {
    return true;
}

public boolean ready() throws IOException {
    synchronized (lock) {
        ensureOpen();
        return (count - pos) > 0;
    }
}

//注意与字节写入流的区别
public void close() {
    buf = null;
}

---

2.CharArrayWriter

结构图，同样的与字节数组输出流没有大差别

成员变量，同上，不在阐述。

构造函数，不指定数组长度时默认 32。

public CharArrayWriter() {
    this(32);
}

public CharArrayWriter(int initialSize) {
    if (initialSize < 0) {
        throw new IllegalArgumentException("Negative initial size: " + initialSize);
    }
    buf = new char[initialSize];
}

wirter 方法

//写入单个字符
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;
    }
}

append 方法

//将指定字符添加到此 writer，并返回此 writer
public CharArrayWriter append(CharSequence csq) {
    String s = (csq == null ? "null" : csq.toString());
    write(s, 0, s.length());
    return this;
}

//将指定字符序列添加到此 writer，并返回此 writer
public CharArrayWriter append(CharSequence csq) {
    String s = (csq == null ? "null" : csq.toString());
    write(s, 0, s.length());
    return this;
}

//将指定字符序列的子序列添加到此 writer，并返回此 writer
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;
}

剩余的方法，只贴出代码，不再探究

public char toCharArray()[] {
    synchronized (lock) {
        return Arrays.copyOf(buf, count);
    }
}

public String toString() {
    synchronized (lock) {
        return new String(buf, 0, count);
    }
}

public void writeTo(Writer out) throws IOException {
    synchronized (lock) {
        out.write(buf, 0, count);
    }
}

public int size() {
    return count;
}

public void reset() {
    count = 0;
}

public void flush() {
}

//注意与字节读取流的区别
public void close() {
}