Java 日看一类（56）之IO包中的StringWriter类

该类无引入包

继承自Writer类

该类的类头注释如下：

/**
 * A character stream that collects its output in a string buffer, which can
 * then be used to construct a string.
 * <p>
 * Closing a <tt>StringWriter</tt> has no effect. The methods in this class
 * can be called after the stream has been closed without generating an
 * <tt>IOException</tt>.
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */

大意如下：

该字符输出流可以收集输出的可组装成完整字符串的字符串缓冲

关闭函数对StringWriter无效，该方法在该流已关闭后调用不会产生IO异常

该类含有如下的成员变量：

将要输出的字符串的缓冲区

private StringBuffer buf;

该类含有如下的成员方法：

构造函数（默认构造函数

public StringWriter() {
    buf = new StringBuffer();
    lock = buf;
}

构造函数（指定缓冲区大小

public StringWriter(int initialSize) {
    if (initialSize < 0) {
        throw new IllegalArgumentException("Negative buffer size");
    }
    buf = new StringBuffer(initialSize);
    lock = buf;
}

写出一个字符

public void write(int c) {
    buf.append((char) c);
}

写出一个字符数组

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);
}

写出一个字符串

public void write(String str) {
    buf.append(str);
}

写出一个字符串中的部分

public void write(String str, int off, int len)  {
    buf.append(str.substring(off, off + len));
}

向该缓冲区添加字符序列（实际调用字符串写入函数

public StringWriter append(CharSequence csq) {
    if (csq == null)
        write("null");
    else
        write(csq.toString());
    return this;
}

向缓冲添加字符序列的部分

public StringWriter append(CharSequence csq, int start, int end) {
    CharSequence cs = (csq == null ? "null" : csq);
    write(cs.subSequence(start, end).toString());
    return this;
}

向字符缓冲区添加单个字符

public StringWriter append(char c) {
    write(c);
    return this;
}

向缓冲区添加字符串

public String toString() {
    return buf.toString();
}

获得缓冲区（指针）

public StringBuffer getBuffer() {
    return buf;
}

刷新流（没啥用

public void flush() {
}

关闭流（没啥用

public void close() throws IOException {
}

该类的实质实际上是将零碎的输出填充到一个StringBuffer中，然后当你的输入结束之后调用getBuffer函数获得该缓冲区来进行需要的操作。该类相当于在StringBuffer上又做了一层封装，但是也没封装啥东西，如果单纯使用这种零碎拼凑方式的话不如直接使用StringBuffer。主要优势在于继承了Writer类，以后可以根据这个基类结合其他输出流来进行组合，这种做法实际上有点相当于调用接口了。