Java基础知识之CharArrayWriter流的使用

   /**
     *创造默认缓冲区大小的CharArrayWriter对象
     */
    public CharArrayWriter() {
        this(32);
    }
 
    /**
     *  创造指定缓冲区大小的CharArrayWriter对象
     */
    public CharArrayWriter(int initialSize) {
        if (initialSize < 0) {
            throw new IllegalArgumentException("Negative initial size: "
                                               + initialSize);
        }
        buf = new char[initialSize];
    }

/**
     * 字符缓冲区
     */
    protected char buf[];
 
    /**
     * 缓冲区中的当前位置
     */
    protected int count;

    /**
     * 写一个单个字符到缓冲区中
     */
    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;
            
            //判定缓冲区写入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); //本质理解为将缓冲区的内容给写了出去
        }
    }

/**
     * 将缓冲区中的数据转成字符串
     * @return the string.
     */
    public String toString() {
        synchronized (lock) {
            return new String(buf, 0, count);
        }
    }
    
    /**
     * 将缓冲区的数据转成字符数组
     */
    public char toCharArray()[] {
        synchronized (lock) {
            return Arrays.copyOf(buf, count);
        }
    }

  /**
     * 刷新流--无效
     */
    public void flush() { }
 
    /**
      *  关闭流--无效
     */
    public void close() { }

CharArrayWriter( ) 
CharArrayWriter(int numChars) 

// Demonstrate CharArrayWriter. 
import java.io.*; 
class CharArrayWriterDemo { 
 public static void main(String args[]) throws IOException { 
 CharArrayWriter f = new CharArrayWriter(); 
 String s = "This should end up in the array"; 
 char buf[] = new char[s.length()]; 
 s.getChars(0, s.length(), buf, 0); 
 f.write(buf); 
 System.out.println("Buffer as a string"); 
 System.out.println(f.toString()); 
 System.out.println("Into array"); 
 char c[] = f.toCharArray(); 
 for (int i=0; i<c.length; i++) { 
 System.out.print(c[i]); 
 } 
 System.out.println("\nTo a FileWriter()"); 
 FileWriter f2 = new FileWriter("test.txt"); 
 f.writeTo(f2); 
 f2.close(); 
 System.out.println("Doing a reset"); 
 f.reset(); 
 for (int i=0; i<3; i++) 
 f.write('X'); 
 System.out.println(f.toString()); 
 } 
}