黑马程序员_IO流2

------- android培训java培训、期待与您交流！ ----------

缓冲区的出现提高了对数据的读写效率
对应类：BufferedWriter   BufferedReader
缓冲区要结合流才可以使用
在流的基础上对流的功能进行了增强
BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接收默认的大小，在大多数情况下，默认值就足够大了
缓冲区的出现时为了提高流的操作效率而出现的，所以在创建缓冲区之前，必须先有流对象
用缓冲区写入文件的代码示例：

import java.io.FileWriter;


public class BufferedWriter {


	


	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		//创建一个字符写入流对象
		FileWriter fw = new FileWriter("d:\\demo.txt");
		
		//为了提高字符写入流效率，加入了缓冲技术，只要将需要被提高效率的流对象
		//作为参数传递给缓冲区的构造函数即可
		java.io.BufferedWriter bw = new java.io.BufferedWriter(fw);


		for(int x=1; x<5;x++){
			bw.write("abcd"+x);
			bw.newLine(); //提供了跨平台的换行符
			bw.flush();
		}
		bw.flush();
		bw.close();
	}


}

BufferedReader：从字符输入流中读取文件，缓冲各个字符，从而实现字符、数组和行的高效读取。
在进行对象建立的时候需要一个被读取的读取流对象

import java.io.FileReader;
import java.io.*;


/**
 * 字符读取缓冲区
 * @author yzz
 *该缓冲区提供了一个一次读一行的方法readLine，方便与对文本数据的获取，当返回null时，表示读到文件的末尾
 */


public class BufferedReader {


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


}

通过缓冲区copy一个.java文件

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


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


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		BufferedReader br = null;
		BufferedWriter bw = null;
		
		try {
			
			br = new BufferedReader(new FileReader("d:\\BufferedReader.java"));
			bw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
			String line = null;
			while((line=br.readLine())!=null){
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			
		} catch (Exception e) {
			 throw new RuntimeException("读写失败");
		}finally{
			try {
				if(br!=null)
					br.close();
			} catch (Exception e) {
				 throw new RuntimeException("读取关闭失败");
			}
			try{
			if(bw!=null)
				bw.close();
			} catch (Exception e) {
			 throw new RuntimeException("写入关闭失败");
		}
	}
	}


}

readLine方法的原理：无论是读一行，还是读取多个字符，其实最终
都是在硬盘上一个一个读取，所以最终使用的还是read方法一次读一个的方法。
自己写个功能模仿一下FileReader的readline()方法：

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


/**
 * 明白了BufferedReader类中国特有方法readLine的原理后可以
 * 自定义一个类中包含一个功能和readLine一致的方法来模拟一下
 * @author yzz
 *
 */
class MyBufferedReader{
	private FileReader r;
	MyBufferedReader(FileReader fr){
		this.r = r;
	}
	public String myReadLine() throws Exception{
		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);
		}
		return null;
	}
	public void myClose() throws IOException{
		r.close();
	}
}
public class Test1 {


	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		FileReader fr = new FileReader("d:\\demo.txt");
		MyBufferedReader myBuf = new MyBufferedReader(fr);
		String line = null;
		while((line=myBuf.myReadLine())!=null){
			System.out.println(line);
		}
		myBuf.myClose();
	}
}

readline()方法是为了增强read()方法而出现的
这是一种设计模式：装饰设计模式
装饰类通常会通过构造方法接收被装饰的对象，并基于被
装饰的对象的功能提供更强的功能
简单的装饰设计模式的例子：

/**
 * 装饰设计模式：
 * 当想对已有的对象进行功能增强时，可以定义类，将以后对象传入，基于已有的功能
 * 并提供加强功能，那么自定义的该类称为装饰类
 * @author yzz
 *
 */
class Person{
	public void eat(){
		System.out.println("吃饭");
	}
}


class SuperPerson{
	private Person p;
    SuperPerson(Person p) {
		this.p=p;
	}
    public void superEat(){
    	System.out.println("开胃酒");
    	System.out.println("吃饭");
    	System.out.println("甜点");
    	System.out.println("来一根");
    }
}
public class Test2 {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Person p = new Person();
		SuperPerson sp = new SuperPerson(p);
		sp.superEat();
	}
}

装饰模式分析：
MyReader //专门用于读取数据的类
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader{
MyBufferReader(MyTextReader text){}
MyBufferReader(MyMediaReader media){}
}
上面这个类扩展性很差，找到其参数的共同类型，通过多态的形式，可以提高扩展性。
class MyBufferReader extends MyReader{
MyBufferReader(MyReader r){
}
}
MyReader //专门用于读取数据的类
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
装饰模式比继承要灵活，避免了继承体系臃肿
而且降低了类于类之间的关系
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供
了更强的功能，所以装饰类和被装饰类通常是属于同一个体系中的
带行号的装饰类：LineNumberReader lnr = new LineNumberReader(fr);