黑马程序员——IO流（BufferedWriter和BufferedReader）

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

缓冲区的出现是为了提高流的操作效率而出现的

所以在创建缓冲区之前，必须要有流对象
 /*

 字符写入流缓冲区
该缓冲区中提供了一个跨平台的换行符newLine();

 */

实例：
public static void main(String[] args){
FileWriter fw = null;

BufferedReader bufw = null;

try{
//创建一个字符写入流对象
fw =  new FileWriter("buf.txt");
//为了提高字符写入流效率，加入了缓冲技术。只要将需要被提高效率的流对象做为参数传递给缓冲区的构造函数即可。
bufw = new BufferedWriter(fw);
bufw.write("asd");
//只要用到缓冲区，就要刷新
bufw.flush();

}catch(IOException e){
System.out.println(e.toString());
}finally{
if(bufw != null){
//其实关闭缓冲区，就是关闭缓冲区的流对象
try{
bufw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}

}
 /*

 字符读取流缓冲区
该缓冲区提供了一个一次读一行的方法，便于对文本的获取，返回null时表示读到文件末尾

 */

实例：
public static void main(String[] args){
//创建一个读取流对象和文件关联
FileReader fr = null;
//为了提高字符读取流效率，加入了缓冲技术。只要将需要被提高效率的流对象做为参数传递给缓冲区的构造函数即可。

BufferedReader bufr = null;

try{
fr = new FileReader("buf.txt");
bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine()) != null){
System.out.println(str);
}
}catch(IOException e){
System.out.println(e.toString());
}finally{

try{
bufr.close();
}catch(IOException e){
System.out.println(e.toString());
}

}

}

readLine方法原理:
      无论是读一行还是读取多个字符，最终都是在硬盘上一个一个读取，所以最终实用的还是read方法一次读一个的方法。
     通过BufferedReader类中的特有方法readLine可以自定义一个类中包含一个功能和readLine一致的方法
      class myBufferedReader{
             private FileReader r;
             myBufferedReader(FileReader r){
                      this.r = r;
             }
             //可以一次读一行的方法
             public  String myreadLine() throws IOException{
                    //定义一个临时容器，原BufferedReader封装的是字符数组
                    //为了
                   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
                     }else{
                          return null;
                     }

             }
             public void myClose() throws IOException{
                  r.close();
              }
       }
      class myBufferedReaderDemo{
             public 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();
              }
       }
 
myBufferedReader 属于装饰设计模式--------当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的类称为装饰类。
装饰类通常通过构造函数接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
 
疑问：
为什么不直接采用继承呢？不更简单么？