1 IO(二)No19
【
缓冲流：内置了缓冲区，对现有的流对象进行了封装，实现了高效的读写操作并增强了功能
字节缓冲流
BufferedInputStream
BufferedOutputStream
字符缓冲流
BufferedReader
特有方法：readLine():第一行（以换行符为标记，读到换行符代表是一行，不包含换行符）
BufferedWriter
特有方法：newLine():输出一个换行符(根据本地系统相关)
设计模式：
【简单工厂、静态工厂、抽象工厂、单利模式、迭代器模式、观察者模式(接口回调)】
装饰者设计模式：
】
昨天的FileStream系列、FileReader、Writer都是节点流，直接和文件这个节点打交道的。节点流对应的是处理流，它们不直接和文件、网络等终端节点打交道，而是对其他流进行装饰、给其他流添加功能
处理流本身也是InputStream、OutputStream、Reader、Writer的子类，如：
BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter，它们可以给对应的体系中的流进行装饰，添加缓冲功能
字节输入缓冲流：
【
FileInputStream fis = newFileInputStream("g:/output.txt");
//创建一个缓冲字节输入流，装饰了参数中的fis文件输入流，给它添加了缓冲功能
BufferedInputStream bis = new BufferedInputStream(fis);
//读一个字节，但不是直接操作磁盘读，而是从内置的缓存中去读
intn = bis.read();
System.out.println(n);
bis.close(); //关闭bis会自动关闭被装饰着的流
BufferedInputStream bis = new BufferedInputStream(newFileInputStream(
"g:/output.zip"));
intn =0;
while((n=bis.read())!=-1){
//不作任何处理，纯粹为演示效率问题
//效率高，因为不是直接从磁盘上一个个读，而是从缓冲区中一个个读
}
bis.close();//关闭缓存流，里面所装饰着的流也会关闭
】
BufferedInputStream 带缓冲的字节输入流
构造方法:BufferedInputStream(InputStream is)参数是要进行装饰的另一个字节输入流
方法和InputStream基本一致
int read()从缓冲中读一个字节(缓冲空了话就读信息填充)
close()关闭处理流时，会自动关闭被装饰的流
字节输出缓冲流：
【
//用缓存字节输出流装饰文件输出流，添加缓存功能
BufferedOutputStreambos = new BufferedOutputStream(
newFileOutputStream("g:/output.txt"));
bos.write(97);//将数据写到内置缓存中，这里没有实际写到文件中
bos.flush(); //强制刷缓存,刷到文件中
//关闭缓存流，会先刷缓存(97这时候才写到文件里)，所装饰的流也会被自动关闭
bos.close();
BufferedInputStream bis = new BufferedInputStream(newFileInputStream(
"g:/output.zip"));
BufferedOutputStreambos = new BufferedOutputStream(
newFileOutputStream("g:/AAoutput.zip"));
intn =0;
while((n=bis.read())!=-1){
bos.write(n); //写到目标文件的缓存输出流中去
// bos.flush(); //每次都直接操作磁盘，效率极低
}
// bos.flush(); //手动flush
bos.close(); //自动flush
bis.close();
】
BufferedOutputStream 带缓冲的字节输出流
构造方法:BufferedOutputStream(OutputStream os)参数是要进行装饰的另一个字节输出流
方法和OutputStream基本一致
write(int b)向缓冲中写一个字节(缓冲满了话就将缓冲中的所有字节数据一下子刷到被装饰的流中)
flush()刷缓存，强制将缓存中的字节数据刷到被装饰得流中
close()在关闭之前会先隐式调用flush，然后再关闭
关闭处理流时，会自动关闭被装饰的流
字符缓冲流:
【
BufferedReader br =new BufferedReader(new FileReader("g:/output.txt"));
//从缓存中读取一个字符并打印
System.out.println((char)br.read());
br.close();
BufferedReader br =new BufferedReader(new FileReader("g:/output.txt"));
String line = br.readLine(); //读取一行信息，用line指向
System.out.println(line);
//读下一行，打印，也就是第二行
System.out.println(br.readLine());
//读下一行，打印，也就是第三行
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
//读完返回null;
System.out.println(br.readLine());
br.close(); //关闭处理流及其装饰的流
BufferedReader br =new BufferedReader(new FileReader("g:/output.txt"));
String line = null; //存储每次readLine的结果及判断文件尾部
while (true) {
line =br.readLine();//循环读行并赋给line
if (line == null){//如果到达文件尾部
break; //退出循环
}
System.out.println(line);//打印
}
br.close();//关闭处理流和节点流
//制作一个自动批改器，一题一分，最终打印出试卷的成绩
BufferedReaderreader1 = new BufferedReader(new FileReader("g:/answer.txt"));
BufferedReader reader2 = newBufferedReader(new FileReader("g:/tom.txt"));
int count = 0;
while(true){
String line1 =reader1.readLine();
String line2 =reader2.readLine();
if(line1 == null ||line2 ==null){
break;
}
if(line1.trim().equalsIgnoreCase(line2.trim())){
count ++;
}
}
System.out.println(count);
reader1.close();
reader2.close();
】
BufferedReader 带缓冲的字符输入流
构造方法:BufferReader(Reader r)参数是要进行装饰的另一个字符输入流
int read()从缓存中读一个字符，读完的话返回-1，没读完就返回读到的那个字符
String readLine()从缓存中读一行，如果没有读完，返回表示的下一行的字符串，如果读完，返回null
BufferedWriter 带缓冲的字符输出流
构造方法:BufferedWriter(Writer w)参数是要进行装饰的另一个字符输出流
write(int c)往缓存中写一个字符(缓冲满了会自动刷出去)
write(String s)将参数字符串拆成一组字符写到缓存中去
newLine()往缓存中写换行符(windows中换行\r\n,linux\n)
flush()把缓存中的字节信息一下子强制刷到所装饰的流中
close()关闭缓冲流及其装饰的流，并隐式flush()
【
在System类中定义了三个静态字段，分别是三个流对象
1）System.err“标准”错误输出流，可将错误数据输出到屏幕（控制台）
2）System.out“标准”输出流，可将数据输出到屏幕（控制台）
3）System.in“标准”输入流，可获取从键盘录入的数据
转换流
从键盘录入数据所用的流是一个系统提供的标准流，而系统提供的标准路都是字节流
如果直接使用字节流来操作字符数据的话，会出现很多问题，需要做很多额外的操作
我们可以通过转换流将字节流转换成字符流，JDK中一共提供了两个转换流
InputStreamReader：是字节流通向字符流的桥梁
OutputStreamWriter：是字符流通向字节流的桥梁
实际上：字符流=字节流+编码表
//系统提供三个标准流不要手动关闭，一旦关闭就使用不来了了。
】
转换流：将字节流转换成字符流，使其能够输入汉字：
【
FileInputStream fis = newFileInputStream("g:/output.txt");
//使用转换流对其装换
InputStreamReaderisr = new InputStreamReader(fis);
intn=0;
while((n=isr.read())!=-1){
System.out.println((char)n);
}
isr.close();
用转换流指定字符集：
// FileReaderisr = new FileReader("g:/answer.txt");
FileInputStreamfis = new FileInputStream("g:/answer.txt");
//装换为字符流
InputStreamReaderisr = new InputStreamReader(fis,"GBK");
//用缓冲流装饰装换出来的字符流，添加了缓冲的功能
BufferedReaderbr = new BufferedReader(isr);
Stringline = br.readLine(); //读行
System.out.println(line); //打印
br.close();
FileOutputStream fos = newFileOutputStream("g:/answer.txt");
Stringstr = "安卓";
byte[]bytes = str.getBytes("utf-8");
for(byte b : bytes) {
System.out.println(b);
fos.write(b);//将两个汉字对应的4个字节写到文件中去
}
fos.close();
FileInputStream fis = newFileInputStream("g:/output.txt");
//用utf-8的形式将字节转换为字符
InputStreamReaderisr = new InputStreamReader(fis,"utf-8");
System.out.print((char)isr.read());
System.out.print((char)isr.read());
isr.close();
//有时候我们获取到的输入流就是字节流，无法改变，如:System.in
//这时，可以使用InputStreamReader转换为字符流
BufferedReaderbr = new BufferedReader(new InputStreamReader(System.in));
Stringline = null;
//从系统输入读取一行
while((line= br.readLine())!=null){
if(line.equals("exit")){
break;
}
System.out.println(line);
}
/***
*
*获取用户键盘录入的小写数据，并将数据变成大写显示在控制台上，
*如果用户输入的是exit,则结束键盘录入
*
*/
public class TransferDemo {
/*
*从键盘录入数据所用的流是一个系统提供的标准流，而系统提供的标准路都是字节流
*如果直接使用字节流来操作字符数据的话，会出现很多问题，需要做很多额外的操作
*我们可以通过转换流将字节流转换成字符流，JDK中一共提供了两个转换流
* InputStreamReader：是字节流通向字符流的桥梁
* OutputStreamWriter：是字符流通向字节流的桥梁
*/
publicstatic void main(String[] args) throws IOException {
//InputStreamReader:是字节流通向字符流的桥梁
BufferedReaderbr = new BufferedReader(new InputStreamReader(System.in));
//OutputStreamWriter:是字符流通向字节流的桥梁
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringline = null;
//从键盘录入一行数据，以换行符为标记
while((line= br.readLine()) != null){
if("exit".equalsIgnoreCase(line)){
break;
}
bw.write(line.toUpperCase());
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
}
】
转换流可以用来将字节流转换为字符流
InputStreamReader将字节输入流转换为字符输入流
构造方法:InputStreamReader(InputStream is)参数就是要转换为字符流的字节流，构造方法调用后转换即成功，接下来就可以对构造出来的字符流进行操作
(有另一个重载构造方法，可以在new的时候指定字符集)
【
//已经有一个字节输出流，想往里写utf-8格式的中文
FileOutputStream fos= new FileOutputStream("g:/answer.txt");
//用转换流装饰节点流，得到一个字符流，转换过程中使用utf-8编码格式
OutputStreamWriter osw = newOutputStreamWriter(fos,"utf-8");
osw.write('征');//这个字符会先以utf-8格式转换为3个字节，再写到底层的流中
osw.write('程');
osw.close();
】
OutputStreamWriter将字节数出流转换为字符输出流
构造方法:OutputStreamWriter(OutputStream os)参数就是要转换为字符流的字节流
(可以在双参重载构造方法中指定字符集)
实例：
【
public class Demo3 {
publicstatic void main(String[] args) throws IOException {
// test1();
//按照指定的字符写数据
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(
newFileOutputStream("trans.txt"), "UTF-8"));
bw.write("钱今凡vjdjb12521");
bw.newLine();
bw.write("小强......");
bw.close();
BufferedReaderbr = new BufferedReader(new InputStreamReader(
newFileInputStream("trans.txt"), "UTF-8"));
System.out.println(br.readLine());
System.out.println(br.readLine());
br.close();
}
privatestatic void test1() throws IOException {
/*
* FileReader是InputStreamReader的子类，是一个便捷类 这个类使用了默认的编码和字节缓冲区
*/
/*
* 如果编码不统一会出现乱码情况 FileReader fr = newFileReader("e:\\testabc.txt");
* char[] cbuf = new char[1024]; int len =fr.read(cbuf);
* System.out.println(new String(cbuf, 0,len));
*/
//使用指定的编码来读取指定文本文件中的数据
FileInputStreamfis = new FileInputStream("E:\\testabc.txt");
//将字节流转换为字符流 实际上：字符流 = 字节流 + 字符编码
InputStreamReaderosr = new InputStreamReader(fis, "UTF-8");
char[]cbuf = new char[1024];
intlen = osr.read(cbuf);
System.out.println(newString(cbuf, 0, len));
}
}
】
