了解下JAVA的java io进修（二十二） BufferedReader(字符缓冲输出流) - 仓酷云

packagejava.io;
publicclassBufferedReaderextendsReader{
privateReaderin;
//字符缓冲区
privatecharcb[];
//nChars是cb缓冲区中字符的总的个数
//nextChar是下一个要读取的字符在cb缓冲区中的地位
privateintnChars,nextChar;
//暗示“标志有效”。它与UNMARKED的区分是：
//(01)UNMARKED是压根就没有设置过标志。
//(02)而INVALIDATED是设置了标志，可是被标志地位太长，招致标志有效！
privatestaticfinalintINVALIDATED=-2;
//暗示没有设置“标志”
privatestaticfinalintUNMARKED=-1;
//“标志”
privateintmarkedChar=UNMARKED;
//“标志”能标志地位的最年夜长度
privateintreadAheadLimit=0;/*ValidonlywhenmarkedChar>0*/
//skipLF(即skipLineFeed)是“是不是疏忽换行符”标志
privatebooleanskipLF=false;
//设置“标志”时，保留的skipLF的值
privatebooleanmarkedSkipLF=false;
//默许字符缓冲区巨细
privatestaticintdefaultCharBufferSize=8192;
//默许每行的字符个数
privatestaticintdefaultExpectedLineLength=80;
//创立“Reader”对应的BufferedReader对象，sz是BufferedReader的缓冲区巨细
publicBufferedReader(Readerin,intsz){
super(in);
if(sz<=0)
thrownewIllegalArgumentException("Buffersize<=0");
this.in=in;
cb=newchar[sz];
nextChar=nChars=0;
}
//创立“Reader”对应的BufferedReader对象，默许的BufferedReader缓冲区巨细是8k
publicBufferedReader(Readerin){
this(in,defaultCharBufferSize);
}
//确保“BufferedReader”是翻开形态
privatevoidensureOpen()throwsIOException{
if(in==null)
thrownewIOException("Streamclosed");
}
//添补缓冲区函数。有以下两种情形被挪用：
//(01)缓冲区没无数据时，经由过程fill()能够向缓冲区添补数据。
//(02)缓冲区数据被读完，需更新时，经由过程fill()能够更新缓冲区的数据。
privatevoidfill()throwsIOException{
//dst暗示“cb中添补数据的肇端地位”。
intdst;
if(markedChar<=UNMARKED){
//没有标志的情形，则设dst=0。
dst=0;
}else{
//delta暗示“以后标志的长度”，它即是“下一个被读取字符的地位”减往“标志的地位”的差值；
intdelta=nextChar-markedChar;
if(delta>=readAheadLimit){
//若“以后标志的长度”凌驾了“标志下限(readAheadLimit)”，
//则抛弃标志！
markedChar=INVALIDATED;
readAheadLimit=0;
dst=0;
}else{
if(readAheadLimit<=cb.length){
//若“以后标志的长度”没有凌驾了“标志下限(readAheadLimit)”，
//而且“标志下限(readAheadLimit)”小于/即是“缓冲的长度”；
//则先将“下一个要被读取的地位，间隔我们标志的置符的间隔”间的字符保留到cb中。
System.arraycopy(cb,markedChar,cb,0,delta);
markedChar=0;
dst=delta;
}else{
//若“以后标志的长度”没有凌驾了“标志下限(readAheadLimit)”，
//而且“标志下限(readAheadLimit)”年夜于“缓冲的长度”；
//检察本栏目更多出色内容：http://www.bianceng.cn/Programming/Java/
//则从头设置缓冲区巨细，并将“下一个要被读取的地位，间隔我们标志的置符的间隔”间的字符保留到cb中。
charncb[]=newchar[readAheadLimit];
System.arraycopy(cb,markedChar,ncb,0,delta);
cb=ncb;
markedChar=0;
dst=delta;
}
//更新nextChar和nChars
nextChar=nChars=delta;
}
}
intn;
do{
//从“in”中读取数据，并存储到字符数组cb中；
//从cb的dst地位入手下手存储，读取的字符个数是cb.length-dst
//n是实践读取的字符个数；若n==0(即一个也没读到)，则持续读取！
n=in.read(cb,dst,cb.length-dst);
}while(n==0);
//假如从“in”中读到了数据，则设置nChars(cb中字符的数量)=dst+n，
//而且nextChar(下一个被读取的字符的地位)=dst。
if(n>0){
nChars=dst+n;
nextChar=dst;
}
}
//从BufferedReader中读取一个字符，该字符以int的体例前往
publicintread()throwsIOException{
synchronized(lock){
ensureOpen();
for(;;){
//若“缓冲区的数据已被读完”，
//则先经由过程fill()更新缓冲区数据
if(nextChar>=nChars){
fill();
if(nextChar>=nChars)
return-1;
}
//若要“疏忽换行符”，
//则对下一个字符是不是是换行符举行处置。
if(skipLF){
skipLF=false;
if(cb[nextChar]==
){
nextChar++;
continue;
}
}
//前往下一个字符
returncb[nextChar++];
}
}
}
//将缓冲区中的数据写进到数组cbuf中。off是数组cbuf中的写进肇端地位，len是写进长度
privateintread1(char[]cbuf,intoff,intlen)throwsIOException{
//若“缓冲区的数据已被读完”，则更新缓冲区数据。
if(nextChar>=nChars){
if(len>=cb.length&&markedChar<=UNMARKED&&!skipLF){
returnin.read(cbuf,off,len);
}
fill();
}
//若更新数据以后，没有任何变更；则加入。
if(nextChar>=nChars)return-1;
//若要“疏忽换行符”，则举行响应处置
if(skipLF){
skipLF=false;
if(cb[nextChar]==
){
nextChar++;
if(nextChar>=nChars)
fill();
if(nextChar>=nChars)
return-1;
}
}
//拷贝字符操纵
intn=Math.min(len,nChars-nextChar);
System.arraycopy(cb,nextChar,cbuf,off,n);
nextChar+=n;
returnn;
}
//对read1()的封装，增加了“同步处置”和“堵塞式读取”等功效
publicintread(charcbuf[],intoff,intlen)throwsIOException{
synchronized(lock){
ensureOpen();
if((off<0)||(off>cbuf.length)||(len<0)||
((off+len)>cbuf.length)||((off+len)<0)){
thrownewIndexOutOfBoundsException();
}elseif(len==0){
return0;
}
intn=read1(cbuf,off,len);
if(n<=0)returnn;
while((n<len)&&in.ready()){
intn1=read1(cbuf,off+n,len-n);
if(n1<=0)break;
n+=n1;
}
returnn;
}
}
//读取一行数据。ignoreLF是“是不是疏忽换行符”
StringreadLine(booleanignoreLF)throwsIOException{
StringBuffers=null;
intstartChar;
synchronized(lock){
ensureOpen();
booleanomitLF=ignoreLF||skipLF;
bufferLoop:
for(;;){
if(nextChar>=nChars)
fill();
if(nextChar>=nChars){/*EOF*/
if(s!=null&&s.length()>0)
returns.toString();
else
returnnull;
}
booleaneol=false;
charc=0;
inti;
/*Skipaleftover
,ifnecessary*/
if(omitLF&&(cb[nextChar]==
))
nextChar++;
skipLF=false;
omitLF=false;
charLoop:
for(i=nextChar;i<nChars;i++){
c=cb[i];
if((c==
)||(c==)){
eol=true;
breakcharLoop;
}
}
startChar=nextChar;
nextChar=i;
if(eol){
Stringstr;
if(s==null){
str=newString(cb,startChar,i-startChar);
}else{
s.append(cb,startChar,i-startChar);
str=s.toString();
}
nextChar++;
if(c==){
skipLF=true;
}
returnstr;
}
if(s==null)
s=newStringBuffer(defaultExpectedLineLength);
s.append(cb,startChar,i-startChar);
}
}
}
//读取一行数据。不疏忽换行符
publicStringreadLine()throwsIOException{
returnreadLine(false);
}
//跳过n个字符
publiclongskip(longn)throwsIOException{
if(n<0L){
thrownewIllegalArgumentException("skipvalueisnegative");
}
synchronized(lock){
ensureOpen();
longr=n;
while(r>0){
if(nextChar>=nChars)
fill();
if(nextChar>=nChars)/*EOF*/
break;
if(skipLF){
skipLF=false;
if(cb[nextChar]==
){
nextChar++;
}
}
longd=nChars-nextChar;
if(r<=d){
nextChar+=r;
r=0;
break;
}
else{
r-=d;
nextChar=nChars;
}
}
returnn-r;
}
}
//“下一个字符”是不是可读
publicbooleanready()throwsIOException{
synchronized(lock){
ensureOpen();
//若疏忽换行符为true；
//则判别下一个标记是不是是换行符，如果的话，则疏忽
if(skipLF){
if(nextChar>=nChars&&in.ready()){
fill();
}
if(nextChar<nChars){
if(cb[nextChar]==
)
nextChar++;
skipLF=false;
}
}
return(nextChar<nChars)||in.ready();
}
}
//一直前往true。由于BufferedReader撑持mark(),reset()
publicbooleanmarkSupported(){
returntrue;
}
//标志以后BufferedReader的下一个要读取地位。关于readAheadLimit的感化，参考前面的申明。
publicvoidmark(intreadAheadLimit)throwsIOException{
if(readAheadLimit<0){
thrownewIllegalArgumentException("Read-aheadlimit<0");
}
synchronized(lock){
ensureOpen();
//设置readAheadLimit
this.readAheadLimit=readAheadLimit;
//保留下一个要读取的地位
markedChar=nextChar;
//保留“是不是疏忽换行符”标志
markedSkipLF=skipLF;
}
}
//重置BufferedReader的下一个要读取地位，
//将其复原到mark()中所保留的地位。
publicvoidreset()throwsIOException{
synchronized(lock){
ensureOpen();
if(markedChar<0)
thrownewIOException((markedChar==INVALIDATED)
?"Markinvalid"
:"Streamnotmarked");
nextChar=markedChar;
skipLF=markedSkipLF;
}
}
publicvoidclose()throwsIOException{
synchronized(lock){
if(in==null)
return;
in.close();
in=null;
cb=null;
}
}
}

复制代码