如题，忘给一个演示程序。。

1. /**  
   
2. * 通过系统缓冲字节流类提高IO操作效率  
   
3. *   
   
4. * @param fileFrom  
   
5. * @param fileTo  
   
6. */  
   
7. public static void readWriteBuffer(String fileFrom, String fileTo) {   
   
8.     InputStream inBuffer = null;   
   
9.     OutputStream outBuffer = null;   
   
10.   
    
11.     try {   
    
12.         inBuffer = new BufferedInputStream(new FileInputStream(fileFrom));   
    
13.         outBuffer = new BufferedOutputStream(new FileOutputStream(fileTo));   
    
14.   
    
15.         int b;   
    
16.         byte[] buff = new byte[1024];   
    
17.       
    
18.         while ((b = inBuffer.read(buff)) != -1) {   
    
19.             outBuffer.write(buff);   
    
20.         }   
    
21.     } catch (FileNotFoundException e) {   
    
22.         e.printStackTrace();   
    
23.     } catch (IOException e) {   
    
24.         e.printStackTrace();   
    
25.     } finally {   
    
26.         try {   
    
27.             if (inBuffer != null) {   
    
28.                 inBuffer.close();   
    
29.                 inBuffer = null;   
    
30.             }   
    
31.             if (outBuffer != null) {   
    
32.                 outBuffer.close();   
    
33.                 outBuffer = null;   
    
34.             }   
    
35.         } catch (IOException e) {   
    
36.             e.printStackTrace();   
    
37.         }   
    
38.     }   
    
39. }  
    

复制代码

缓冲字符流

一．缓冲字符流

1.采用缓冲处理是为了提高效率，如果没有缓存，例如FileReader对象，每次调用read()方法进行读操作时，都会直接去文件中读取字节，转换成字符并返回，这样频繁的读取文件效率很低。

2原理就是将数组进行封装。

3. .缓冲的字符流的出现提高了对流的操作效率，缓冲的存在是为了增强流的功能，因此在建立缓冲的字符流对象时，要先有流对象的存在。

二．字符缓冲输入流BufferedReader类

1.构造方法

public BufferedReader（Read in）：创建一个使用默认大小输入缓冲区的缓冲字符输入流。

Public BufferedReader(Reader in，int sz)：创建了一个使用指定大小输入缓冲区的缓冲字符输入流。其中 sz指输入缓冲区的大小，如果sz<=0，则抛出IllegalArgumentException.

2.实例方法

Public String readLine（）throws IOException：读取一个文本行。

import java.io.*;





public class BufferedIODemo2 {

    public static void main(String[] args){

       FileReader fr=null;

       BufferedReader bw=null;

       try {

           fr=new FileReader("res/demo.txt");

           bw=new BufferedReader(fr,255);

         

           String str=null;

           while((str=bw.readLine())!=null){

              System.out.println(str);

           }

       } catch (FileNotFoundException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } catch (IOException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }finally{

           if(bw!=null)

              try {

                  bw.close();

              } catch (IOException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }

       }

    }



}



三．字符缓冲输出流BufferedWriter类

1.构造方法

Public BufferedWriter（writer out）：创建一个使用默认大小输出缓冲区的缓冲字符输出流。

Public BufferedWriter（Writer out，int sz）：创建一个使用给定大小输出缓冲区的新缓冲字符输出流。其中 sz指输入缓冲区的大小，如果sz<=0，则抛出IllegalArgumentException.

2.实例方法

Public void newLine（）throw IOException：写入一个行分隔符，行分隔符字符串由系统属性line.separator定义，而不是单个新行（\n）符。

import java.io.*;





public class BufferedIODemo {



    /**

     * @param args

     */

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       FileWriter fw=null;

       BufferedWriter bw=null;

       try {

            fw=new FileWriter("res/" +

                  "demo.txt");

            bw=new BufferedWriter(fw);

            bw.write("hell");

            bw.newLine();

            bw.write("java");

            bw.newLine();

            bw.flush();

       } catch (IOException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } finally{

           if(bw!=null){

              try {

                  bw.close();

              } catch (IOException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }

              }  

           }

      

    }



}



四．装饰设计模式和继承有什么区别？

1.装饰设计模式比继承有更好的灵活性

2. 增加的这些子类都是在使用缓冲技术。可不可以对缓冲技术进行描述，将需要增强的对象传递给缓冲区即可。

3. 出现的新的问题：该类虽然完成对已有两个对象的增强。但是当有新的对象出现时，还要继续在该类中添加构造函数。这样不利于扩展和维护。

4. 解决方法：将对这些对象父类型进行操作即可。这就是多态，提高了程序的扩展性。同时BufferedWriter中一样具体write方法，只不过是增强后的write。所以BuferedWriter也应该是Writer中的一个子类。