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

转自：https://www.xuebuyuan.com/2015312.html

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

1、StringWriter类

1. public class StringWriter extends Writer {
2. private StringBuffer buf;     // 一个可变的、线程安全的字符串变量
3. public StringWriter() {
4. buf = new StringBuffer();
5. lock = buf;               // lock是一个Object类的实例对象
6. }
7. public StringWriter(int initialSize) {
8. if (initialSize < 0) {
9. throw new IllegalArgumentException("Negative buffer size");
10. }
11. buf = new StringBuffer(initialSize);
12. lock = buf;
13. }
14. public void write(int c) {
15. buf.append((char) c);
16. }
17. public void write(char cbuf[], int off, int len) {
18. if ((off < 0) || (off > cbuf.length) || (len < 0) || ((off + len) > cbuf.length) || ((off + len) < 0)) {
19. throw new IndexOutOfBoundsException();
20. } else if (len == 0) {
21. return;
22. }
23. buf.append(cbuf, off, len);
24. }
25. public void write(String str) {
26. buf.append(str);
27. }
28. public void write(String str, int off, int len)  {
29. buf.append(str.substring(off, off + len));
30. }
31. //...
32. }

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

1. public class testStringWriter {
2. public static void main(String[] args) {
3. char[] x = { 'm', 'n' };
4. StringWriter s = new StringWriter(20);
5. s.write(x, 0, 1);
6. s.write('a');
7. s.write("bcd");
8. s.write("012", 1, 2);
9. System.out.println(s.toString());
10. }
11. }

最后的输出结果如下：

mabcd12

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

1. public StringWriter append(CharSequence csq) {
2. if (csq == null)
3. write("null");
4. else
5. write(csq.toString());
6. return this;
7. }
8. public StringWriter append(CharSequence csq, int start, int end) {
9. CharSequence cs = (csq == null ? "null" : csq);
10. write(cs.subSequence(start, end).toString());
11. return this;
12. }
13. public StringWriter append(char c) {
14. write(c);
15. return this;
16. }

2、StringReader类

下面来看一下StringReader类的read()方法，如下：

1. public int read() throws IOException {
2. synchronized (lock) {
3. ensureOpen();
4. if (next >= length)
5. return -1;
6. return str.charAt(next++);
7. }
8. }
9. public int read(char cbuf[], int off, int len) throws IOException {
10. synchronized (lock) {
11. ensureOpen();
12. if ((off < 0) || (off > cbuf.length) || (len < 0) ||
13. ((off + len) > cbuf.length) || ((off + len) < 0)) {
14. throw new IndexOutOfBoundsException();
15. } else if (len == 0) {
16. return 0;
17. }
18. if (next >= length)
19. return -1;
20. int n = Math.min(length - next, len);
21. str.getChars(next, next + n, cbuf, off);
22. next += n;
23. return n;
24. }
25. }

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

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

读取时还需要确保输入输出流打开（ensureOpen()方法），源码如下：

1. private void ensureOpen() throws IOException {
2. if (str == null)
3. throw new IOException("Stream closed");
4. }

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

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

1. private int next = 0;              // 下一个要读取的字符标记
2. private int mark = 0;              // 对字符串中的字符进行标记
3. public boolean markSupported() {   // 是否支持标记读取
4. return true;
5. }
6. /**
7. * 标记当前的位置，调用reset()方法后可以重新回到标记处读取数据.
8. */
9. public void mark(int readAheadLimit) throws IOException {
10. if (readAheadLimit < 0){
11. throw new IllegalArgumentException("Read-ahead limit < 0");
12. }
13. synchronized (lock) {
14. ensureOpen();
15. mark = next;   // 标记为当前的读取位置
16. }
17. }
18. public void reset() throws IOException {
19. synchronized (lock) {
20. ensureOpen();
21. next = mark;
22. }
23. }

mark()和reset()方法同样需要实现同步。所以看出StringReader和StringWriter类是线程安全的。

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

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

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

1. public void close() {
2. str = null;
3. }

帮助JVM尽快回收这个对象。

思考：如果不调用这个方法，会不会产生内存泄漏？