java之19天 IO 字符缓冲区(一)

BufferedWriter
BufferedReader

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * IO中 字符流的缓冲技术
 * 1)缓冲区的出现提高了对数据的读写效率.
 * 2)对应类.
 *    BufferedWriter
 *    BufferedReader
 * 3)缓冲区要结合流才可以使用.
 * 4)在流的基础上对流的功能进行了增强.
 *
 *
 * 缓冲区的出现是为了提高流的操作效率而出现的.
 * 所以在创建缓存区之前,必须要先有流对象.
 * 
 * 该缓冲区中 提供了一个跨平台的换行符.newLine();
 */
public class BufferedWriterDemo {

	public static void main(String[] args) throws IOException {
	
		//创建一个字符写入流对象
		FileWriter fw=new FileWriter("buf.txt");
		
		//为了提高字符写入流的效率,加入缓存技术.
		//只要将需要提高效率的流对象作为参数传递给缓冲区的构造函数即可
		BufferedWriter bufw=new BufferedWriter(fw);
		bufw.write("ab\r\ncde");
	
		bufw.newLine();// 换行  window:\r\n  linux:\n

		for(int x=0;x<5;x++){
			bufw.write("abc"+x);
			bufw.newLine();  //自动换行方法
			bufw.flush();  //必须要刷新, 如果不小心停电了 ,这样不会丢失数据
		}
		
		
		//记住只要用到缓冲区 ,就要记得刷行.
		bufw.flush();
		
		//其实关闭缓冲区,就是关闭缓冲区中的流对象
		bufw.close();
		//这句不用写了
		//fw.close();
		
		
	}

}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * 读取缓冲区
 * 该缓冲区提供了一个一次读取一行的方法 readLine,(但不包含行终止符号.即不会换行,这是有效文本)方便对文本数据的获取.
 * readLine():只返回回车符好之前的数据内容,并不返回回车符号
 * 当返回null 表示读取到了文件的末尾
 */
public class BufferedReaderDemo {


	public static void main(String[] args) throws IOException {
		//创建一个读取流对象和文件相关联.
		
		FileReader fr=new FileReader("buf.txt");
		
		//为了提高效率,加入缓冲技术
		//将字符读取流对象作为参数传递给缓冲对象的构造函数
		BufferedReader  bufr=new BufferedReader(fr);
		
		/*String s1=bufr.readLine();  //提供的读取一行
		System.out.println("s1:"+s1);
		*/
		String line=null;
		while((line=bufr.readLine())!=null){
			System.out.println(line);
		}
		bufr.close();
		
	}

}

自定义BufferedReader模拟里面的功能

import java.io.FileReader;
import java.io.IOException;


/**
 * 明白了BufferedReader类中的特有方法,readLine的原理后
 * 可以自定义一个类中包含一个功能和readLine一致的方法.
 */
public class MyBufferedReaderDemo {

	public static void main(String[] args) throws IOException {

		FileReader fr=new FileReader("E:\\workspace4\\exam\\src\\com\\itheima\\day18\\SystemDemo.java");
		
		MyBufferedReader mbufr=new MyBufferedReader(fr);
		
		String line=null;
		
		while((line=mbufr.myReaderLine())!=null){
			System.out.println(line);
		}
		mbufr.myClose();
	}

}

//装饰设计模式  模拟 BufferedReader 对 read() 
class MyBufferedReader{
	private FileReader fr;
	MyBufferedReader(FileReader fr){
		this.fr=fr;
	}
	//可以一次读一行的方法.
	public String myReaderLine() throws IOException{
		//定义一个临时的容器,原BufferedReader封装的是一个字符数组
		//为了演示方便,定义一个StringBuilder容器,因为最终还是要将数据变成字符串.
		StringBuilder sb=new StringBuilder();
		int ch=0;
		while((ch=fr.read())!=-1){
			if(ch=='\r')
				continue;
			
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0) //如果最后一行没有 \n  会丢失最后一行
			return sb.toString();
		return null;
		
	}
	
	public void myClose() throws IOException{
		fr.close();
	}
}

MyBufferedReader1的升级完善

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;


/**
 * 明白了BufferedReader类中的特有方法,readLine的原理后
 * 可以自定义一个类中包含一个功能和readLine一致的方法.
 */
public class MyBufferedReaderDemo1 {

	public static void main(String[] args) throws IOException {

		FileReader fr=new FileReader("E:\\workspace4\\exam\\src\\com\\itheima\\day18\\SystemDemo.java");
		
		MyBufferedReader1 mbufr=new MyBufferedReader1(fr);
		
		String line=null;
		
		while((line=mbufr.myReaderLine())!=null){
			System.out.println(line);
		}
		mbufr.close();
	}

}

//装饰设计模式  模拟 的完善
class MyBufferedReader1 extends Reader{
	//现在只能对FileReader进行装饰
	//private FileReader fr;
	
	//这样我们就可以对 Reader 这样 一组类进行 装饰了
	private Reader fr;
	//MyBufferedReader1(FileReader fr){
	MyBufferedReader1(Reader fr){
		this.fr=fr;
	}
	//可以一次读一行的方法.
	public String myReaderLine() throws IOException{
		//定义一个临时的容器,原BufferedReader封装的是一个字符数组
		//为了演示方便,定义一个StringBuilder容器,因为最终还是要将数据变成字符串.
		StringBuilder sb=new StringBuilder();
		int ch=0;
		while((ch=fr.read())!=-1){
			if(ch=='\r')
				continue;
			
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0) //如果最后一行没有 \n  会丢失最后一行
			return sb.toString();
		return null;
		
	}
	
	
	
	//复写 Reader中的close
	public void close() throws IOException{
		fr.close();
	}
	
	//复写 Reader中的read
	public int read(char[] cbuf, int off, int len) throws IOException {
		// TODO Auto-generated method stub
		return fr.read(cbuf, off, len);
	}
}

装饰上设计模式

/**
 * 装饰设计模式:
 * 当想对已有的对象进行功能增强时候
 * 可以定义类,将已有对象传入,基于已有的功能,并提供加强功能.
 * 那么自定义的该类称为"装饰类"
 * 
 * 装饰类通常会通过构造方法接受被装饰的对象.
 * 并基于被装饰的对象功能提供更强的功能.
 * 
 * 
 * 装饰类和 继承 的区别
 * MyReader //专门用户读取数据的类
 *   |--myTextReader
 *   |--myMediaReader
 * 
 * 一年后,发现 以上的读取速度有点慢,想到了缓冲技术
 *  MyReader //专门用户读取数据的类
 *   |--myTextReader
 *   	|--MyBufferTextReader
 *   |--myMediaReader
 *      |--MyMediaReader
 *      
 * 一年后 出现了新的数据类型
 *   MyReader //专门用户读取数据的类
 *   |--myTextReader
 *   	|--MyBufferTextReader
 *   |--myMediaReader
 *      |--MyBufferMediaReader
 *   |--MyDataReader
 *      |--myBufferDataReader
 *  
 *  既然上面使用的缓冲技术都是同一种技术,这样发现上面的结构 都比较 臃肿
 *  
 *  class MyBufferReader{
 *  	myBufferTextReader(myTextReader r){
 *  
 *  	}
 *  	myBufferMediaReader(myMediaReader r){
 *  
 *  	}
 *  	myBufferDataReader(myDataReader r){
 *  
 *  	}
 *  }
 *  
 *  又发现以上的类的扩展性极差
 *  找到其参数的共同类型,通过多态的形式,可以提高扩展性
 *  
 *  class MyBufferReader extends MyReader{
 *  
 *  	MyReader r;  //组合结构
 *  	MyBufferReader(MyReader r){
 *  		this.r=r;
 *  	}
 *  	
 *  	public void myBufferReader(){
 *  		//缓存操作
 *  	}
 *  }
 *  
 *  //最后的结构是 
 *  MyReader //专门用户读取数据的类
 *   |--myTextReader
 *   |--myMediaReader
 *   |--myDataReader
 *   |--myBufferReader
 *   
 *  总结:
 *    装饰类比继承跟灵活,避免了继承体系的臃肿
 *    而且降低了类和类之间的关系.
 *    装饰类因为增强已有兑对象,具备的功能和已有的是相同的,只不过是提供更强大的功能
 *    所以装饰类 和被装饰类通常都属于一个体系.
 *    由以前的继承结构 -->变成了 -->组合结构
 * 
 */
public class DecorationDemo {
	
	public static void main(String[] args) {
		Person p=new Person();
		p.chifan(); //以前吃饭是这样的
		System.out.println("========生活富裕了==========");
		SuperPerson sp=new SuperPerson(p);
		sp.superChifan();
		
	}
}

class Person{
	public void chifan(){
		System.out.println("吃饭");
	}
}

class SuperPerson{
	Person p;
	SuperPerson(Person p){
		this.p=p;
	}
	
	//后来人升级了, 吃饭的方法也不同了.
	public void superChifan(){
		System.out.println("喝汤");
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
		System.out.println("来一根");
	}
}

通过缓冲区复制一个.java文件

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 通过缓冲区复制一个.java文件
 */
public class CopyTextByBuf {

	public static void main(String[] args) {
		
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try {
			bufr=new BufferedReader(new FileReader("E:\\workspace4\\exam\\src\\com\\itheima\\day18\\SystemDemo.java"));
			bufw=new BufferedWriter(new FileWriter("bufWriter_copy.txt"));
			
			String line=null;  //这就变成了中转站  替换了 char[]  
			while((line=bufr.readLine())!=null){
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		} catch (Exception e) {
			e.printStackTrace(); //读写失败
		}finally{
			if(bufr!=null)
				try{
					bufr.close();
				}catch(IOException e){
					throw new RuntimeException("读取关闭失败");
				}
			if(bufw!=null)
				try{
					bufw.close();
				}catch (IOException e) {
					throw new RuntimeException("写入关闭失败");
				}
			
		}
		
		
		
	}

}