基本概念
Reader/Writer(字符读取流/字符写入流),是所有字符操作流的父类。
同字节流不同,它们本身是抽象类。
继承关系如下:
源码分析
1.Reader
类结构图
成员变量
/*
* 用来在流上同步操作的对象。
* 为了提高效率,字符流对象可以使用其自身以外的对象来保护关键部分。
* 因此,子类应使用此字段中的对象,而不是 this 或者同步的方法。
*/
protected Object lock;
// 表示跳跃(丢弃)操作时能丢弃的最大字符数量
private static final int maxSkipBufferSize = 8192;
// 跳跃缓冲数组,用来保存跳跃操作时读取的字符内容
private char skipBuffer[] = null;
构造函数
protected Reader() {
// 将字符流对象赋于 lock,说明我们操作的不是字符流本身,而是 lock
this.lock = this;
}
protected Reader(Object lock) {
if (lock == null) {
throw new NullPointerException();
}
this.lock = lock;
}
read 方法,这里定义了 4 种读取方式。
①② 依靠 ③ 实现。
③ 为抽象方法,留给子类实现。
④ 是字节输入流所没有的读取方式。
//① 读取单个字符
public int read() throws IOException {
char cb[] = new char[1];
//关键-->创建了只有1个字符容量的数组,然后将字符读入该字符数组。
if (read(cb, 0, 1) == -1) {
//到达 I/O 流末尾返回 -1
return -1;
} else {
//否则返回整数字符,范围为 0 到 65535 之间 (0x00-0xffff),
return cb[0];
}
}
//② 将字符读入数组,返回读取的字符数
public int read(char cbuf[]) throws IOException {
return read(cbuf, 0, cbuf.length);
}
//③ 将字符读入数组的某一部分。抽象方法,留给子类实现
public abstract int read(char cbuf[], int off, int len) throws IOException;
//④ 将字符读入指定的字符缓冲区,返回读取的字符数
public int read(java.nio.CharBuffer target) throws IOException {
//检查字符缓冲区中剩余可空闲的空间
int len = target.remaining();
char[] cbuf = new char[len];
int n = read(cbuf, 0, len);
if (n > 0){
target.put(cbuf, 0, n);
}
return n;
}
skip,跳跃操作。具体原理在 InputStream 中已介绍过了,这里不在细说。
与 InputStream 的 skip 方法不同,字符输入流的 skip 方法是同步操作,是线程安全的。
public long skip(long n) throws IOException {
if (n < 0L) {
throw new IllegalArgumentException("skip value is negative");
}
//nn 表示将要创建的缓冲数组的容量大小
int nn = (int) Math.min(n, maxSkipBufferSize);
//关键 --> 与字节输入流不同,这里是同步操作
synchronized (lock) {
// 创建跳跃缓冲数组
if ((skipBuffer == null) || (skipBuffer.length < nn)) {
skipBuffer = new char[nn];
}
//表示要跳过的字符数量
long r = n;
// 将需要跳过(丢弃)的字符读取到数组
while (r > 0) {
int nc = read(skipBuffer, 0, (int) Math.min(r, nn));
if (nc == -1) {
break;
}
//表示剩下未跳跃(丢弃)的字符
r -= nc;
}
//返回跳跃(丢弃)的字符数量
return n - r;
}
}
剩余方法
// 如果确保流的下一次读取不堵塞,则返回 true,否则返回 false,但并不表示下一次读取会堵塞
public boolean ready() throws IOException {
return false;
}
public boolean markSupported() {
return false;
}
public void mark(int readAheadLimit) throws IOException {
throw new IOException("mark() not supported");
}
public void reset() throws IOException {
throw new IOException("reset() not supported");
}
abstract public void close() throws IOException;
2.Writer
类结构图
成员变量
//缓冲数组,默认写入的内容会暂时保存在该字符数组里
private char[] writeBuffer;
//缓冲数组的大小,不可变
private final int writeBufferSize = 1024;
//同 Reader
protected Object lock;
构造函数
protected Writer() {
this.lock = this;
}
protected Writer(Object lock) {
if (lock == null) {
throw new NullPointerException();
}
this.lock = lock;
}
wirter 方法,这里定义 5 种写入方式
①② 依靠 ③ 实现。
③ 为抽象方法,留给子类实现。
④⑤ 是字节输出流所没有的读取方式。
// ①写入单个字符
public void write(int c) throws IOException {
synchronized (lock) {
if (writeBuffer == null) {
writeBuffer = new char[writeBufferSize];
}
//将字符的 int 写入缓冲数组
writeBuffer[0] = (char) c;
write(writeBuffer, 0, 1);
}
}
// ②写入字符数组
public void write(char cbuf[]) throws IOException {
write(cbuf, 0, cbuf.length);
}
// ③写入字符数组的某一部分,抽象方法
public bstract void write(char cbuf[], int off, int len) throws IOException;
// ④写入字符串
public void write(String str) throws IOException {
write(str, 0, str.length());
}
// ⑤写入字符串的某一部分
public void write(String str, int off, int len) throws IOException {
synchronized (lock) {
char cbuf[];
//将要写入的字符串长度与缓冲数组的容量比较
if (len <= writeBufferSize) {
if (writeBuffer == null) {
writeBuffer = new char[writeBufferSize];
}
cbuf = writeBuffer;
} else {
cbuf = new char[len];
}
//String 的方法,将字符串复制到字符数组
str.getChars(off, (off + len), cbuf, 0);
write(cbuf, 0, len);
}
}
append 方法,这里定义了 3 种添加方式。
具体实现通过调用相应的 write 方法完成,并返回 Writer 对象
// 将指定字符添加到此 writer,并返回此 writer
public Writer append(char c) throws IOException {
write(c);
return this;
}
// 将指定字符序列添加到此 writer,并返回此 writer
public Writer append(CharSequence csq) throws IOException {
if (csq == null){
//字符序列为空,则添加 null 这4个字符到 writer
write("null");
}else{
write(csq.toString());
}
return this;
}
// 将指定字符序列的子序列添加到此 writer,并返回此 writer
public Writer append(CharSequence csq, int start, int end) throws IOException {
CharSequence cs = (csq == null ? "null" : csq);
write(cs.subSequence(start, end).toString());
return this;
}
剩余方法
public abstract void flush() throws IOException;
public abstract void close() throws IOException;