标签：
这两个类将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尽快回收这个对象。
思考：如果不调用这个方法，会不会产生内存泄漏？
标签：
原文地址：http://www.cnblogs.com/Crow00/p/4537406.html
