Java 7之传统I/O - 字符类 StringReader和StringWriter

这两个类将String类适配到了Reader和Writer接口,在StringWriter类实现的过程中,真正使用的是StringBuffer,前面讲过,StringBuffer是一个可变类,由于Writer类中有许多字符串的操作,所以这个类用起来比较方便;在StringReader类中只定义一个String类即可,因为只涉及到类的读取,而没有修改等的操作,不会创建多个字符串而造成资源浪费。


1、StringWriter类


public class StringWriter extends Writer {
	
    private StringBuffer buf;     // 一个可变的、线程安全的字符串变量
    public StringWriter() {
        buf = new StringBuffer();
        lock = buf;               // lock是一个Object类的实例对象
    }
    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));
    }


  //...
}
可以看出,提供了各种各样的write()方法,如可以将字符数组追加到字符串尾、单个字符添加到字符串末尾行等等,源代码的实现都非常简单,下面来举个例子:

public class testStringWriter {
	public static void main(String[] args) {
		char[] x = { 'm', 'n' };
		StringWriter s = new StringWriter(20); 
		s.write(x, 0, 1);

		s.write('a');
		s.write("bcd");
		s.write("012", 1, 2);
		System.out.println(s.toString());
	}
}

最后的输出结果如下:

mabcd12

或者还可以使用append()方法将要添加的内容追加到字符串末尾。如下源代码:

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


2、StringReader类


下面来看一下StringReader类的read()方法,如下:

   public int read() throws IOException {  
        synchronized (lock) {
            ensureOpen();
            if (next >= length)
                return -1;
            return str.charAt(next++);
        }
    }

    public int read(char cbuf[], int off, int len) throws IOException {  
        synchronized (lock) {
            ensureOpen();
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
            if (next >= length)
                return -1;
            int n = Math.min(length - next, len);
            str.getChars(next, next + n, cbuf, off);
            next += n;
            return n;
        }
    }

可以每次读取一个字符,也可以将多个字符一次性读入一个数组中。在读取的过程中还支持回退读取、跳读取等操作。

lock在StringWriter类初始化时已经赋值为buf实例,由于StringBuffer是线程安全的,所以在读取的时候,加锁同一个StringBuffer实例就可以实现写入和读取的同步。切不可在方法上加synchronized关键字,因为这样默认的锁是StringReader类实例,无法与StringBuffer实现同步。

读取时还需要确保输入输出流打开(ensureOpen()方法),源码如下:

 private void ensureOpen() throws IOException {
        if (str == null)
            throw new IOException("Stream closed");
 }

也就是确保有内容可以读取。如果没有则直接抛出异常。


来看一下使用标记读取字符串,主要的方法有3个,如下:

    private int next = 0;              // 下一个要读取的字符标记
    private int mark = 0;              // 对字符串中的字符进行标记
    public boolean markSupported() {   // 是否支持标记读取
        return true;
    }

    /**
     * 标记当前的位置,调用reset()方法后可以重新回到标记处读取数据.
     */
    public void mark(int readAheadLimit) throws IOException { 
        if (readAheadLimit < 0){
            throw new IllegalArgumentException("Read-ahead limit < 0");
        }
        synchronized (lock) {
            ensureOpen();
            mark = next;   // 标记为当前的读取位置
        }
    }

    public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            next = mark;
        }
    }
mark()和reset()方法同样需要实现同步。所以看出StringReader和StringWriter类是线程安全的。


下面简单示例一下这个类中重要方法的应用。

                StringReader sr=new StringReader("abcdefg");
		System.out.println((char)sr.read());  // a
		// 如果支持标记读取,则标记当前的读取位置,也就是字符串中的第二个字符b
		if(sr.markSupported()){
			sr.mark(3);                       // 查看源码后知道,这个参数3无任何意义。
		}
		System.out.println((char)sr.read());  // b
		System.out.println((char)sr.read());  // c
		sr.reset();                           // 从做标记的mark开始读取
		System.out.println((char)sr.read());  // 当前读取位置设置为mark标记的值,输出为b
		
	    char[] x=new char[3];
	    sr.read(x,0,2);
		System.out.println(String.valueOf(x));// bc

如果sr对象结尾时最好调用close()方法进行关闭,close()方法源代码如下:

 public void close() {
        str = null;
 }
帮助JVM尽快回收这个对象。


思考:如果不调用这个方法,会不会产生内存泄漏?














你可能感兴趣的:(Java,7,I/O源码)