[重学Java基础][JavaIO流][Part.2]缓冲字符输入输出流
BufferedReader
概述
BufferedReader缓冲字符数组输入流，继承了所有字符输入流的超类Reader类，自带缓存区，可以一次读入缓冲区大小的字符内容，并且提供了按行读取功能
通过包装Reader对象来发挥作用
很明显 这是一个处理流 包装流 一般包装InputStreamReader，FileReader对象
官方注释
从一个输入的字符流中读取文本，为字符、数组、一行文本的高效读取提供字符缓冲功能。
缓冲区的大小可能是特殊设定值，可能是使用默认的大小。默认的大小已经足够解决大部分问题。
一般情况下，每一个read请求由一个Reader类发起，使底层进行对字节流或byte流执行相应的读取请求。
对一些read()函数开销较大的的Reader类，(例如：FileReaders和InputStreamReaders)使用BufferedReader类进行封装是很明智的。
例：
BufferedReader in = new BufferedReader(new FileReader("file.in"));
如果没由进行缓冲，对read()和readline()调用会直接从文件中读取一次byte数据，转换成字符格式并返回，这是十分不明智的做法。
程序对文本数据使用DataInputStream时，在合适的情况下可以局部替换DataInputStream为BufferedReader
源码分析
成员属性
public class BufferedReader extends Reader {
读取的数据源
private Reader in;
缓冲字符数组 流的实际内容体
private char cb[];
nChars 缓冲区中字符总个数
nextChar 下一个要读取的字符位置
private int nChars, nextChar;
“标记无效”的标志
private static final int INVALIDATED = -2;
未设置标记
private static final int UNMARKED = -1;
默认情况下无标记字符 所以markedChar是未设置标记
private int markedChar = UNMARKED;
可标记位置能标记的最大长度 只有先设置了markedChar后此变量才能生效
private int readAheadLimit = 0;
是否跳过换行字符 就是是否忽略换行 默认不忽略
private boolean skipLF = false;
设置标记时 是否忽略换行
private boolean markedSkipLF = false;
默认缓冲字符数组大小
private static int defaultCharBufferSize = 8192;
默认每一行的字符个数
private static int defaultExpectedLineLength = 80;
……
}
成员方法
- 构造方法
接受一个输入流对象 并按照入参sz的大小创建字符缓冲区
public BufferedReader(Reader in, int sz) {
super(in);
if (sz <= 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.in = in;
cb = new char[sz];
nextChar = nChars = 0;
}
接受一个输入流大小 并创建默认大小的字符缓冲区
public BufferedReader(Reader in) {
this(in, defaultCharBufferSize);
}
填入缓冲区方法 真正将数据填入缓冲区的方法 其他读取方法都是此方法的装饰器
缓冲区没有数据时，通过fill()法以向缓冲区填充数据 缓冲区数据被读完，需更新时，通过fill()可以更新缓冲区的数据
private void fill() throws IOException {
缓冲数组填充的开始位置
int dst;
if (markedChar <= UNMARKED) {
无标记的情况下 默认初始位置为缓冲区头部位置0
dst = 0;
} else {
如果有标记 则标记区间长度delta 等于下一个要读取的位置与被标记的位置的距离
int delta = nextChar - markedChar;
if (delta >= readAheadLimit) {
若标记区间长度delta大于读取的限制(超过了标记上限，
即流下次读取的位置已经超过了标记位置) 则标记无效
markedChar = INVALIDATED;
readAheadLimit = 0;
dst = 0;
} else {
if (readAheadLimit <= cb.length) {
若未超过标记上限，则将下一个读取位置到标记位置开始的流内容复制到cb
System.arraycopy(cb, markedChar, cb, 0, delta);
markedChar = 0;
dst = delta;
} else {
如果标记上限大于缓冲流的总长度 则将下一个读取位置到标记位置开始的
流内容复制到新的字符数组ncb中 再将cb设置为ncb
char ncb[] = new char[readAheadLimit];
System.arraycopy(cb, markedChar, ncb, 0, delta);
cb = ncb;
markedChar = 0;
dst = delta;
}
nextChar = nChars = delta;
}
}
int n;
do {
从输入流in中读取数据 并存储到cb中 读取长度为cb.length-dst
如果没读到就继续读取
n = in.read(cb, dst, cb.length - dst);
} while (n == 0);
if (n > 0) {
如果从输入流in中读到了数据，则设置nChars(cb中字符的数目)=dst+n，
并且nextChar(下一个被读取的字符的位置)=dst。
nChars = dst + n;
nextChar = dst;
}
}
从数据源读取数据方法 每次读入一个字符
public int read() throws IOException {
线程加锁 说明读取时线程安全的
synchronized (lock) {
ensureOpen();
for (;;) {
若下一个读取的数据位置大于缓冲区的大小（缓冲区数据全部读取）
则先用fill()按方法刷新缓冲区 再读取
if (nextChar >= nChars) {
fill();
刷新后缓冲区仍然没有新数据 则返回-1 读入结束
if (nextChar >= nChars)
return -1;
}
是否忽略换行符
if (skipLF) {
skipLF = false;
if (cb[nextChar] == '\n') {
nextChar++;
continue;
}
}
return cb[nextChar++];
}
}
}
从数据源读取数据方法 每次读入指定长度字符内容
private int read1(char[] cbuf, int off, int len) throws IOException {
if (nextChar >= nChars) {
如果读取的字符游标位置超过了当前的缓冲区大小
且读取的长度小于缓冲区大小 未设置标记 不忽略换行符
则直接从输入流读取 不经过缓冲区
if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {
return in.read(cbuf, off, len);
}
fill();
}
刷新缓冲区之后 读取的字符游标位置仍然超过了当前的缓冲区大小
则直接读入停止
if (nextChar >= nChars) return -1;
如果忽略换行符
if (skipLF) {
重置标记
skipLF = false;
下个读入字符为换行符 跳过
if (cb[nextChar] == '\n') {
nextChar++;
超过缓冲区位置 刷新缓冲区
if (nextChar >= nChars)
fill();
仍然超过则停止读入
if (nextChar >= nChars)
return -1;
}
}
int n = Math.min(len, nChars - nextChar);
System.arraycopy(cb, nextChar, cbuf, off, n);
nextChar += n;
return n;
}
从数据源读取数据方法 每次读入一行内容
readLine()方法实际上调用了一个包内部方法 readLine(boolean ignoreLF)
public String readLine() throws IOException {
return readLine(false);
}
String readLine(boolean ignoreLF) throws IOException {
StringBuffer s = null;
int startChar;
synchronized (lock) {
ensureOpen();
确认这一行读取是否需要读取换行符
boolean omitLF = ignoreLF || skipLF;
bufferLoop:
for (;;) {
if (nextChar >= nChars)
fill();
下个读入字符游标位置超过缓冲区大小 读入结束
if (nextChar >= nChars) {
if (s != null && s.length() > 0)
return s.toString();
else
return null;
}
boolean eol = false;
char c = 0;
int i;
是否跳过一个换行符
if (omitLF && (cb[nextChar] == '\n'))
nextChar++;
skipLF = false;
omitLF = false;
可以看到读取一行方法 实际上也是判断字符是否是换行符或者回车符
如果是 停止读入 把结束标志置位真
charLoop:
for (i = nextChar; i < nChars; i++) {
c = cb[i];
if ((c == '\n') || (c == '\r')) {
eol = true;
break charLoop;
}
}
startChar = nextChar;
nextChar = i;
如果结束符为真 则返回读入内容字符串
if (eol) {
String str;
if (s == null) {
str = new String(cb, startChar, i - startChar);
} else {
s.append(cb, startChar, i - startChar);
str = s.toString();
}
nextChar++;
if (c == '\r') {
skipLF = true;
}
return str;
}
if (s == null)
s = new StringBuffer(defaultExpectedLineLength);
s.append(cb, startChar, i - startChar);
}
}
}
代码示例
例1 按行读入文件中字符 注意文件必须是UTF-8格式的 否则会乱码
BufferedReader br = new
BufferedReader(new FileReader("d:/a.txt"));
String str;
while((str=br.readLine())!=null)
{
System.out.println(str);
}
输出
第一行 四月是你的谎言
第二行 比宇宙更远的地方
第三行 不死者之王
第四行 关于我的女友是个一本正经的碧池这件事
例2 按字符读入并转换
BufferedReader br = new BufferedReader(new FileReader("d:/a.txt"));
int c;
while((c=br.read())!=-1)
{
System.out.print((char)c);
}
结果同上
例3 标记并重置
BufferedReader br = new BufferedReader(new FileReader("d:/a.txt"));
注意这里的读入限制为大于读入字符数 读入字符数为55 小于等于这个值reset时会报错
br.mark(100);
String str;
while((str=br.readLine())!=null)
{
System.out.println(str);
}
br.reset();
int c;
while((c=br.read())!=-1)
{
System.out.print((char)c);
}
输出
第一行 四月是你的谎言
第二行 比宇宙更远的地方
第三行 不死者之王
第四行 关于我的女友是个一本正经的碧池这件事
第一行 四月是你的谎言
第二行 比宇宙更远的地方
第三行 不死者之王
第四行 关于我的女友是个一本正经的碧池这件事
典型错误
1.
BufferedReader br = new BufferedReader(new FileReader("d:/a.txt"));
String str;
while((str=br.readLine())!=null)
{
System.out.println(br.readLine());
}
输出
第二行 比宇宙更远的地方
第四行 关于我的女友是个一本正经的碧池这件事
隔一行丢失了一行数据 因为流被读取后游标移动 不会重复读入 所以只能按例1方式操作
BuffererWriter
概述
BufferedWriter缓冲字符数组输出流，继承了所有字符输出流的超类Writer类，自带缓存区，可以一次写出缓冲区大小的字符内容，并且提供了按行写出功能
通过包装Writer对象来发挥作用
很明显 这是一个处理流 包装流 一般包装InputStreamWriter，FileWriter对象
官方注释
向字符输出流写入文本时，对字符进行缓冲处理是一种高效的处理方式，尤其是逐个的字符写入，数组结构写入或者字符串结构写入
缓冲区的大小可被设定，默认大小足以满足一般情况的需求
提供了newLine（）方法，提供了基于不同平台的行分割方法，因为不是所有平台都是用’\n’作为换行符，所以使用newLine方法是首选。
一般情况下，Writer类总是立即将数据输出到底层的字符流或比特流中。除非程序需要即刻输出，否则使用BufferedWriter封装时最好的选择。（对于write（）方法开销较大的Writer类十分必要）
例如：
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));
对PrintWriter类进行了缓冲。如果没有缓冲，任意一个对print方法的调用将会使字符转化为byte并且立刻写入到文件中，这是非常低效率的。
源码分析
成员属性
输出的数据汇
private Writer out;
缓冲字符数组
private char cb[];
下个读入字符游标位置nextChar 缓冲区最大长度nChars
private int nChars, nextChar;
默认的缓冲区大小
private static int defaultCharBufferSize = 8192;
文本换行符 流创建的时刻会自动赋值
private String lineSeparator;
成员方法
构造方法 创建一个默认缓冲区大小的缓冲输出流或者指定大小的缓冲输出流
public BufferedWriter(Writer out) {
this(out, defaultCharBufferSize);
}
public BufferedWriter(Writer out, int sz) {
super(out);
if (sz <= 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.out = out;
cb = new char[sz];
nChars = sz;
nextChar = 0;
可以看到lineSeparator 文本换行符是通过底层方法创建的
按当前系统的方式创建分本换行符
lineSeparator = java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction("line.separator"));
}
刷新输出流 可以看到刷新方法flush()内部调用了包级方法flushBuffer()方法
flushBuffer()方法则真正实现了将缓冲区字符数组写入到输出流的操作
public void flush() throws IOException {
synchronized (lock) {
flushBuffer();
out.flush();
}
}
void flushBuffer() throws IOException {
synchronized (lock) {
ensureOpen();
if (nextChar == 0)
return;
out.write(cb, 0, nextChar);
nextChar = 0;
}
}
换行方法 写入一个换行符 避免显示输出换行符可能引起的一些问题
public void newLine() throws IOException {
write(lineSeparator);
}
写入方法 读入字符数组缓冲内容 并写入到底层流
public void write(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;
}
如果写入的字符数组大于缓冲区大小 则刷新缓冲区 并直接写入下层流
可以看到是直接调用底层流out的写入方法
if (len >= nChars) {
flushBuffer();
out.write(cbuf, off, len);
return;
}
int b = off, t = off + len;
while (b < t) {
int d = min(nChars - nextChar, t - b);
System.arraycopy(cbuf, b, cb, nextChar, d);
b += d;
nextChar += d;
if (nextChar >= nChars)
flushBuffer();
}
}
}
代码示例
向控制台写入字符
BufferedReader br = new BufferedReader(new FileReader("d:/b.txt"));
BufferedWriter bwo=new BufferedWriter(new PrintWriter(System.out));
String str;
while((str=br.readLine())!=null)
{
bwo.write(str);
bwo.newLine();
}
bwo.flush();
输出结果
1.紫罗兰永恒花园
2.龙王的工作！
3.Fate/EXTRA Last Encore
4.citrus～柑橘味香气～
写入到文件
BufferedWriter bw=new BufferedWriter(new FileWriter("d://c.txt"));
List<String> list= Arrays.asList("比宇宙更远的地方","魔卡少女樱 CLEAR CARD篇","卫宫家今天的饭","博多豚骨拉面团");
for (String s : list) {
bw.write(s,0,s.length());
bw.newLine();
}
bw.flush();
输出结果
比宇宙更远的地方
魔卡少女樱 CLEAR CARD篇
卫宫家今天的饭
博多豚骨拉面团
注意 输出到文件 重复执行会覆盖上一次执行的内容