public StringWriter() {}
public StringWriter(int initialSize) {}

private StringBuffer buf;

public void write(int c) {}
public void write(char cbuf[], int off, int len){}
public void write(String str) {}
public void write(String str, int off, int len){}
public StringWriter append(CharSequence csq){}
public StringWriter append(CharSequence csq, int start, int end){}
public StringWriter append(char c){}
public String toString() {}
public StringBuffer getBuffer() {}
public void flush() {}
public void close() {}

public StringReader(String s) {}

  private String str;
  private int length;
  private int next = 0;
  private int mark = 0;

private void ensureOpen(){}
public int read(){}
public int read(char cbuf[], int off, int len){}
public long skip(long ns){}
public boolean ready(){}
public boolean markSupported() {}
public void mark(int readAheadLimit){}
public void reset(){}
public void close(){}

public class StringWriterDemo {
  public static void main(String[] args) throws IOException {
    testStringWriter();
    testStringReader();
    testOfAnotherStringWriter();
  }
  //測(cè)試StringWriter
  private static void testStringWriter() throws IOException {
    StringWriter sw = new StringWriter();
    sw.append("this is a");
    sw.write("demo of StringWriter");
    System.out.println(sw.toString());
    sw.close();
  }
   
  //測(cè)試StringReader
  private static void testStringReader() throws IOException {
   String content = "this is a demo of StringReader";
   StringReader sr = new StringReader(content);
   int c;
   while((c=sr.read())!=-1) {
     System.out.println((char)c);
   }
    sr.close();
  }
  
  //將讀取的數(shù)據(jù)先寫到StringWriter流中,然后直接調(diào)用toString()方法打印結(jié)果
  private static void testOfAnotherStringWriter() throws IOException {
    FileReader fr = new FileReader("D:\\java.txt");
    BufferedReader br = new BufferedReader(fr);
    StringWriter sw = new StringWriter();
    int n;
    char cbuf[] = new char[1024];
    while((n=br.read(cbuf))!=-1) {
      sw.write(cbuf, 0, n);
    }
    System.out.println(sw.toString());
    fr.close();
    br.close();
  }
}

public class StringWriter extends Writer {
    //StringWriter中緩沖功能是通過StringBuffer來實(shí)現(xiàn)的.
    private StringBuffer buf;
 
    //創(chuàng)建默認(rèn)緩沖為16個(gè)字符的StringWriter.默認(rèn)的StringBuffer實(shí)際是大小為16個(gè)字符的字符數(shù)組.
    public StringWriter() {
        buf = new StringBuffer();
        lock = buf;
    }
 
    //創(chuàng)建指定大小StringBuffer的StringWriter,也就是指定了initialSize個(gè)字符的字符數(shù)組.
    public StringWriter(int initialSize) {
        if (initialSize < 0) {
            throw new IllegalArgumentException("Negative buffer size");
        }
        buf = new StringBuffer(initialSize);
        lock = buf;
    }
 
    //向流寫入單個(gè)字符c
    public void write(int c) {
        buf.append((char) c);
    }
 
    //將字符數(shù)組cbuf中off位置開始,len個(gè)字符寫到流中
    public void write(char cbuf[], int off, int len) {
        if ((off < 0) || (off > cbuf.length) || (len < 0) ||
            ((off + len) > cbuf.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        buf.append(cbuf, off, len);
    }
 
    //將字符串str寫到流中
    public void write(String str) {
        buf.append(str);
    }
 
    //將字符串str中off位置開始,len個(gè)字符寫到流中
    public void write(String str, int off, int len)  {
        buf.append(str.substring(off, off + len));
    }
 
    //將字符序列csq添加到流中.
    public StringWriter append(CharSequence csq) {
        if (csq == null)
            write("null");
        else
            write(csq.toString());
        return this;
    }
 
    //將字符序列csq中start位置到end之間的字符添加到流中
    public StringWriter append(CharSequence csq, int start, int end) {
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }
 
    //向流中添加一個(gè)字符c
    public StringWriter append(char c) {
        write(c);
        return this;
    }
 
    //將流中字符轉(zhuǎn)換成字符串返回.
    public String toString() {
        return buf.toString();
    }
 
    //返回流的內(nèi)容,即StringBuffer
    public StringBuffer getBuffer() {
        return buf;
    }
 
    //刷新流,沒有具體實(shí)現(xiàn).
    public void flush() {
    }
 
    //關(guān)閉流后讀取數(shù)據(jù)不會(huì)拋出異常,因?yàn)闆]有具體實(shí)現(xiàn)
    public void close() throws IOException {
    }
 
}

public class StringReader extends Reader {
    //流中實(shí)際數(shù)據(jù)就是通過構(gòu)造方法傳入str字符串.
    private String str;
    //字符串str的長(zhǎng)度
    private int length;
    //下一個(gè)要讀取字符的位置.
    private int next = 0;
    //標(biāo)記的位置.
    private int mark = 0;
 
    //創(chuàng)建一個(gè)StringReader流,參數(shù)傳入的是字符串s
    public StringReader(String s) {
        this.str = s;
        this.length = s.length();
    }
 
   //確保流沒有關(guān)閉,實(shí)際判斷的是StringReader構(gòu)造方法是否有傳入字符串.
    private void ensureOpen() throws IOException {
        if (str == null)
            throw new IOException("Stream closed");
    }
 
    //讀取單個(gè)字符
    public int read() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (next >= length)
                return -1;
            return str.charAt(next++);
        }
    }
 
    //將緩沖區(qū)中最多l(xiāng)en個(gè)字符寫到字符數(shù)組cbuf中,位置從off開始,長(zhǎng)度為len個(gè)
    public int read(char cbuf[], int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();
            //檢測(cè)參數(shù)的合法性
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
            //超過字符串的長(zhǎng)度,返回-1
            if (next >= length)
                return -1;
            //剩余可讀取的字符為length-next,
            //如果len超過剩余可讀取字符,實(shí)際只能讀取剩余可讀取字符
            //如果len小于剩余可讀取字符,實(shí)際上讀取的是len個(gè)字符
            int n = Math.min(length - next, len);
            str.getChars(next, next + n, cbuf, off);
            next += n;
            return n;
        }
    }
 
    //跳過ns個(gè)字符,返回跳過的字符數(shù)
    public long skip(long ns) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (next >= length)
                return 0;
            // Bound skip by beginning and end of the source
            //緩沖區(qū)中剩余字符數(shù)與要跳過的字符數(shù)比較.取較小值
            long n = Math.min(length - next, ns);
            n = Math.max(-next, n);
            next += n;
            return n;
        }
    }
 
    //流是否準(zhǔn)備讀取.
    public boolean ready() throws IOException {
        synchronized (lock) {
        ensureOpen();
        return true;
        }
    }
 
    //流是否支持標(biāo)記
    public boolean markSupported() {
        return true;
    }
 
   //標(biāo)記緩沖區(qū)中當(dāng)前位置,readAheadLimit表示的是在保留標(biāo)記的情況下,最大可讀取的字符數(shù)
    public void mark(int readAheadLimit) throws IOException {
        if (readAheadLimit < 0){
            throw new IllegalArgumentException("Read-ahead limit < 0");
        }
        synchronized (lock) {
            ensureOpen();
            mark = next;
        }
    }
 
    //將緩沖區(qū)當(dāng)前位置重置到標(biāo)記位置
    public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            next = mark;
        }
    }
 
    //關(guān)閉流,釋放相關(guān)資源(實(shí)際只是將流中內(nèi)容字符串置為空)
    public void close() {
        str = null;
    }
}