CharArrayReader、CharArrayWriter 字符数组输入输出流

内存操作流：（与类型相关的流）

1.字节数组流 ：ByteArrayInputStream字节数组输入流与ByteArrayOutputStream字节数组输出流

2.字符数据流： CharArrayReader字符数组输入流与CharArrayWriter字符数组输出流

3.字符串流：StringReader 与 StringWriter

内存流的作用：

1、用于操作字节数组的流对象，其实它们就是对应设备为内存的流对象。

2、该流的关闭是无效的，因为没有调用过系统资源。close()

3、按照流的读写思想操作数组中元素。

CharArrayReader 字符数组输入流

源码剖析：
 此类实现一个可用作字符输入流的字符缓冲区。

• 继承关系：

class CharArrayReader extends Reader

• 构造方法：

// 根据指定的 char 数组创建一个 CharArrayReader
    public CharArrayReader(char buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }
// 根据指定的 char 数组创建一个 CharArrayReader,具有偏移量和长度
   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;
    }

• 基本属性：

 /** The character buffer. 字符缓冲区*/
    protected char buf[]; 

    /** The current buffer position.当前缓冲区位置 */
    protected int pos;

    /** The position of mark in buffer. 缓冲区中标记的位置*/
    protected int markedPos = 0;

    /**
     *  The index of the end of this buffer.  There is not valid
     *  data at or beyond this index. 此缓冲区结尾处的索引
     */
    protected int count;

• 常用方法：

void ensureOpen()：查看当前流是否关闭
int read()：读取单个字符
int read(char b[], int off, int len)： 将字符读入数组的某一部分
long skip(long n)： 跳过字符
boolean ready()：判断此流是否已准备好被读取
boolean markSupported()：判断此流是否支持 mark() 操作（它一定支持）
void mark(int readAheadLimit) ：标记流中的当前位置
void reset()：将该流重置为最新的标记，如果从未标记过，则将其重置到开头
void close()：关闭该流并释放与之关联的所有系统资源

CharArrayWriter 字符数组输出流

• 继承关系：

public
class CharArrayWriter extends Writer 

//继承Writer字符输出流，实现Writer类实现的Appendable（可追加）, Closeable（可克隆）, Flushable（可刷新缓存）

此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。

• 属性：

    /**
     * The buffer where data is stored.存储数据缓冲区-字符数组
     */
    protected char buf[]; 

    /**
     * The number of chars in the buffer.缓冲区存储字符个数
     */
    protected int count;

• 构造方法：

	/**
     * Creates a new CharArrayWriter.
     创建的CharArrayWriter对应的字符数组大小是32。
     */
    public CharArrayWriter() {
        this(32);
    }

    /**
     * Creates a new CharArrayWriter with the specified initial size.
     *  创建一个具有特定初始大小的CharArrayWriter
     * @param initialSize  an int specifying the initial buffer size.
     * @exception IllegalArgumentException if initialSize is negative
     */
    public CharArrayWriter(int initialSize) {
        if (initialSize < 0) {
            throw new IllegalArgumentException("Negative initial size: "
                                               + initialSize);
        }
        buf = new char[initialSize];
    }

• 方法总结：

void write(int c)：写入单个字符到缓冲区

void write(char c[], int off, int len)：批量的写入字符，偏移量（起始位置），写入字符的长度

void write(String str, int off, int len)：将字符串的某一部分写入缓冲区，开始读取字符处的偏移量，要写入的字符数

void writeTo(Writer out)：将缓冲区的内容写入另一个字符流

CharArrayWriter append(CharSequence csq)：将指定的字符序列添加到此 writer；
csq - 要添加的字符序列。如果 csq 为 null，则向此 writer 添加四个字符 "null"
    

CharArrayWriter append(CharSequence csq, int start, int end)：将指定字符序列的子序列添加到此 writer；
csq - 其子序列将被添加的字符序列。如果 csq 为 null，则添加四个字符 "null"，就好像 csq 包含这些字符一样。
start - 子序列中第一个字符的索引
end - 子序列中最后一个字符后面的字符的索引。左闭右开

CharArrayWriter append(char c)：将指定字符添加到此 writer；
底层调用自身write（）方法；

void reset()：重置该缓冲区，以便再次使用它而无需丢弃已分配的缓冲区

char toCharArray()[]：返回输入数据所得到的 char 数组

int size()：返回缓冲区的当前大小

String toString()：将输入数据转换为字符串

void flush()：刷新该流的缓冲

void close()：关闭流

Demo：

public class CharArrayWriterDemo {
    public static void main(String[] args) {
        //建立字符数组输出流
        CharArrayWriter charArrayWriter = new CharArrayWriter(100);//构造函数，初始大小自定义参数
        CharArrayWriter charArrayWriter2 = new CharArrayWriter();//默认大小32

        charArrayWriter.write(99);//写入单个字符
        charArrayWriter.write('A');

        System.out.println(charArrayWriter.toString());//将输入数据转化为字符串
        char[] chars = {'a','b'};
        charArrayWriter.write(chars,0,1);//批量写入
        System.out.println(charArrayWriter.toString());
        String s = "efgh";
        charArrayWriter.write(s,0,3);
        System.out.println(charArrayWriter.toString());
        try {
            charArrayWriter.write("ijklmn");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(charArrayWriter.toString());

        int si = charArrayWriter.size();//返回当前缓冲区大小
        System.out.println(si);

        char[] chars1 = charArrayWriter.toCharArray();//复制输入的char数组
        System.out.println(chars1);

        charArrayWriter.append("llll");
        charArrayWriter.append("animal",0,3);
        //从start开始(包括)到end结束(不包括)的数据，写入到CharArrayWriter中。

        System.out.println(charArrayWriter.toString());


       CharArrayWriter charArrayWriter1 = new CharArrayWriter();//将缓冲区的内容写入另一个字符流
        //charArrayWriter1.write(99);
        try {
            charArrayWriter.writeTo(charArrayWriter1);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(charArrayWriter1.toString());

        charArrayWriter1.flush();//刷新该流的缓冲
        charArrayWriter.reset();//重置缓冲区
        charArrayWriter.close();//关闭流
    }
}