本文深入讲解Java中的字符缓冲流BufferedReader和BufferedWriter的工作原理及使用方法，包括如何提高读写效率，如何处理异常，以及如何自定义类似的缓冲类。
字符流缓冲区
缓冲区的出现提高了对数据的读写效率。
对应类
•BufferedWriter
•BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
类 BufferedWriter
|--java.io.BufferedWriter
public class BufferedWriter
extends Writer
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
| 构造方法摘要 | |
|---|---|
BufferedWriter(Writer out)创建一个使用默认大小输出缓冲区的缓冲字符输出流。 | |
BufferedWriter(Writer out, int sz)创建一个使用给定大小输出缓冲区的新缓冲字符输出流。 | |
缓冲区的出现是为了提高流的操作效率而出现的。
在创建缓冲区之前，必须要先有流对象。
实际上缓冲区是封装了一个数组。
这样我们就不用自己去创建数组了。
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("buffer.txt");
BufferedWriter bufw = new BufferedWriter(fw);
bufw.write("abcdefg");
bufw.newLine();
bufw.write("hijklmn");
bufw.flush();
bufw.newLine();
bufw.write("opq rst");
bufw.close();
}
}
关闭缓冲区，其实就是关闭缓冲区所对应的流对象。
newLine()是跨平台的换行方法，windows平台下换行符是\r\n，Linux平台下换行符是\n
所以newLine方法具体用哪一个换行符是参照jdk的，因为jdk有windows版本和Linux版本。
所以只要你写newLine方法，不管在windows下还是在Linux下都可以换行。
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("buffer.txt");
BufferedWriter bufw = new BufferedWriter(fw);
for(int x = 0; x<5; x++)
{
bufw.write("abcdefg"+x);
bufw.newLine();
bufw.flush();
/*为什么要写一行刷一下呢？
因为写的中途有可能停电或者发生其它特殊情况，
缓冲区的东西会全部丢失，
只有刷到硬盘的东西才得以保存。*/
}
bufw.close();
}
}
类 BufferedReader 是一个装饰类：
|--java.io.BufferedReader
public class BufferedReader
extends Reader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
| 构造方法摘要 | |
|---|---|
BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。 | |
BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。 | |
读取文本的一个特别好的方法：
String | readLine()读取一个文本行。 |
-
返回：
- 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
import java.io.*;
class BufferedReaderDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("buffer.txt");
BufferedReader bufr = new BufferedReader(fr);
String s = null;
while((s=bufr.readLine())!=null)
{
sop(s);
}
bufr.close();
}
}
练习：通过缓冲区复制一个.java文件
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("D:\\buffer.txt");
FileReader fr = new FileReader("BufferedReaderDemo.java");
BufferedWriter bufw = new BufferedWriter(fw);
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
标准处理异常版：
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedWriter bufw = null;
BufferedReader bufr = null;
try
{
bufw = new BufferedWriter(new FileWriter("D:\\buffer.txt"));
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
new RuntimeException("读写文件失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
new RuntimeException("关闭读取流失败");
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
new RuntimeException("关闭写入流失败");
}
}
}
}
}
readLine方法的原理：
import java.io.*;
class MyBufferedReader
{
private FileReader fr;
MyBufferedReader(FileReader fr)
{
this.fr = fr;
}
public String myReadLine()throws IOException
{
StringBuilder sb = new StringBuilder();
int num = 0;
while((num=fr.read())!=-1)
{
if(num=='\r')
continue;
if(num=='\n')
return sb.toString();
sb.append((char)num);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void myClose()throws IOException
{
fr.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("D:\\buffer.txt");
MyBufferedReader myBufr = new MyBufferedReader(fr);
String line = null;
while((line=myBufr.myReadLine())!=null)
{
System.out.println(line);
}
myBufr.myClose();
}
}
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}
class SuperPerson
{
private Person p ;
SuperPerson(Person p)
{
this.p = p;
}
public void superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
System.out.println("来一根");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
//p.chifan();
SuperPerson sp = new SuperPerson(p);
sp.superChifan();
}
}
装饰和继承的区别：
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader media)
{}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。
现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
自定义装饰类：
/*
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader
*/
import java.io.*;
class MyBufferedReader extends Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r = r;
}
//可以一次读一行数据的方法。
public String myReadLine()throws IOException
{
//定义一个临时容器。原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
/*
覆盖Reader类中的抽象方法。
*/
public int read(char[] cbuf, int off, int len) throws IOException
{
return r.read(cbuf,off,len) ;
}
public void close()throws IOException
{
r.close();
}
public void myClose()throws IOException
{
r.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("buf.txt");
MyBufferedReader myBuf = new MyBufferedReader(fr);
String line = null;
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}
myBuf.myClose();
}
}
BufferedReader的直接已知子类：
类 LineNumberReader 也是个装饰类
|--java.io.LineNumberReader
public class LineNumberReader
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和getLineNumber()，它们可分别用于设置和获取当前行号。
默认情况下，行编号从 0 开始。
import java.io.*;
class LineNumberReaderDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("MyBufferedReaderDemo.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null;
lnr.setLineNumber(100);
while((line=lnr.readLine())!=null)
{
sop(lnr.getLineNumber()+""+line);
}
}
}
行号从101开始：
LineNumberReader的原理：
import java.io.*;
class MyLineNumberReader
{
private Reader r;
private int lineNumber;
MyLineNumberReader(Reader r)
{
this.r = r;
}
public int getLineNumber()
{
return lineNumber;
}
public void setLineNumber(int num)
{
this.lineNumber = num;
}
public String myReadLine()throws IOException
{
lineNumber++;
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=r.read())!=-1)
{
if(ch=='\t')
continue;
if(ch=='\n')
return sb.toString();
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void myClose()throws IOException
{
r.close();
}
}
class MyLineNumberReaderDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("BufferedReaderDemo.java");
MyLineNumberReader mylnr = new MyLineNumberReader(fr);
String line = null;
mylnr.setLineNumber(100);
while((line=mylnr.myReadLine())!=null)
{
sop(mylnr.getLineNumber()+":"+line);
}
}
}
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
扫一扫
162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
