黑马程序员_<<字符流的缓冲技术和装饰类(BufferedWriter,BufferedReader,LineNumberReader)>>

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

1.BufferedWriter

BufferedWriter是利用的缓冲技术，操作的是输入流，把Writer对象构造函数的参数传入，首先是把信息读取到缓冲流中，然后再刷新缓冲流，把读到的文件信息传到目的地。这提高了写入的效率。

这里写入的方法增加了newLine()方法，换行，这个是跨平台的操作，不用在写”\r\n”,当关闭缓冲流，同时也关闭了缓冲流中封装的输入字符流。

缓冲区都有自己默认的长度，也可以自己设定长度，一般情况下，默认长度据够用了

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
 
public class BufferedDemo {
  public static void main(String[] args) {
    FileWriter fw=null;//字符流  输入流
    BufferedWriter bw=null;//缓冲流
    try {
       fw=new FileWriter("F:\\demo.txt");
       bw=new BufferedWriter(fw);//将字符流封装到缓冲流中
      for(int i=0;i<3;i++){
          bw.write("java0"+i);
          bw.newLine();//换行
          bw.flush();
       }
    } catch (IOException e) {
      e.printStackTrace();
    }finally{
      if(bw!=null){
         try {
           /*关闭缓冲流，同时也关闭了里面封装的字符流，不需要在关闭字符流，fw*/
           bw.close();
         } catch (IOException e) {
           e.printStackTrace();
         }
      }
    }
 
  }
 
}
 

2.BufferedReader

1. 概述

读取缓冲流，将字符流的读取流传到BufferedReader对象的构造方法中，这样可以提高效率，在读取方面，除了一个一个字节读取和数组读取，增加了读行方法， readLine(),

缓冲区都有自己默认的长度，也可以自己设定长度，一般情况下，默认长度据够用了

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
public class BufferedDemo1 {
  public static void main(String[] args) {
    FileReader fr=null;//字符流输出流
    BufferedReader br=null;//缓冲流
    try {
      fr=new FileReader("F:\\demo.txt");
      br=new BufferedReader(fr);
      /*String readLine()当读取到末尾的时候，返回null
       * 否则返回的是一行的数据*/
      String line=null;
      while((line=br.readLine())!=null){
         System.out.println(line);
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }catch(IOException e1){
      e1.printStackTrace();
    }finally{
      if(br!=null){
         try {
           /*关闭缓冲流，同时也关闭了里面的字符流，不需要在关闭字符流*/
           br.close();
         } catch (IOException e) {
           e.printStackTrace();
         }
      }
    }
 
  }
 
}
结果：
java00
java01
java02

2.readLine原理

其实这是装饰类，用了装饰设计模式，详细参考 黑马程序员_<<装饰设计模式>>

模拟换行

 import java.io.FileReader;
import java.io.IOException;
 
public class MyBufferedReader {
  private FileReader fr = null;
 
  public MyBufferedReader(FileReader fr) {
    super();
    this.fr = fr;
  }
 
  /* 模拟readLine的话，其实里面封装了一个数组，我们为了方便，就封装StringBuilder对象，这样操作方便 */
 
  public String readLine() throws IOException {
    StringBuilder sb = new StringBuilder();
    int ch = -1;
    while ((ch = fr.read()) != -1) {
      //System.out.print(ch+",");  从输入的个数判断出
      if (ch == '\r')//当文件中就存在\r，那此时是否存入StringBuilder中呢，开始我认为是不会存入的，但是结果输出了，难道是读取的时候例如：\r,把\ 和 r分开读取了，这样理解的话，就通顺了
         continue;
      if (ch == '\n')//这里和\r的疑问和理解一样
         return sb.toString();
      else
         sb.append((char) ch);
 
    }
    if (sb.length() != 0)// 这里解决了，最后一样没有回车，防止最后一行不被输出
      return sb.toString();
    return null;
  }
 
  public void close() throws IOException {
    if (fr != null) {
      fr.close();
    }
  }
}
 
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.Date;
importjava.util.Random;
 
public classClassDemo {
      public static void main(String[] args) {
 
           MyBufferedReader br = null;// 缓冲流
           try {
                 br = new MyBufferedReader(newFileReader("F:\\demo.txt"));
 
                 String line = null;
                 while ((line = br.readLine())!= null) {
                      System.out.println(line);
                 }
           } catch (FileNotFoundException e) {
                 e.printStackTrace();
           } catch (IOException e) {
                 e.printStackTrace();
           } finally {
                 if (br != null) {
                      try {
                            br.close();
                      } catch (IOException e) {
                            e.printStackTrace();
                      }
                 }
           }
      }
 
}

结果正确输出。

3. 缓冲技术(复制文件)

package www.fuxi.IO;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class BufferedClass {
 
  public static void main(String[] args) {
    BufferedReader br = null;// 缓冲流读取
    BufferedWriter bw = null;// 缓冲流写入
    try {
      /* 在这里使用匿名类，因为关闭的不需要字符流对象，直接把对象封装到了缓冲流中了 */
      br = new BufferedReader(new FileReader("F:\\demo.txt"));
      bw = new BufferedWriter(new FileWriter("F:\\A\\demo.txt"));
      String line=null;
      while((line=br.readLine())!=null){//读取
         bw.write(line);//写入
         bw.newLine();//换行
         bw.flush();//刷新
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
 
      try {
         if (bw != null) {
           bw.close();
         }
         if (br != null) {
           br.close();
         }
      } catch (IOException e) {
         e.printStackTrace();
      }
 
    }
 
  }
 
}

4. LineNumberReader

1. 概述

这也是一个装饰类。继承了BufferedReader类（这也是一个装饰了类），重写了ReadLine方法，增加了行号的设置和获得。

public class LineNumberDemo{
  public static void main(String[] args) {
    LineNumberReader lnr = null;
 
    try {
      lnr = new LineNumberReader(new FileReader("F:\\ClassDemo.java"));
      String line = null;
      lnr.setLineNumber(10);//在这里也可以自己设置行号的开始
      while ((line = lnr.readLine()) != null) {
        System.out.println(lnr.getLineNumber()+":"+line);
      }
    } catch (FileNotFoundException e) {
      System.out.println("没有找到指定的文件");
    } catch (IOException e) {
      System.out.println("读取失败");
    } finally {
      if (lnr != null) {
         try {
           lnr.close();
         } catch (IOException e) {
           System.out.println("流关闭失败");
         }
      }
    }
 
  }
 
}
 
部分结果：
11:package www.fuxi.IO;
12:
13:importjava.io.FileNotFoundException;
14:import java.io.FileReader;
15:import java.io.IOException;
16:
17:public class ClassDemo {
18: public static void main(String[] args) {
19:
20:   MyBufferedReaderbr = null;// 缓冲流

2. 模拟此类

自己不需要写readLine的原理，直接调用父类的方法即可，然后增加行号的设置和获得。

 import java.io.BufferedReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.Reader;
/*自定义的可以设置行号读取类*/
public class MyLineNumberReader extends BufferedReader {
 
  private Reader r;// 读取流字符流
  private int LineNumber;// 行号
 
  public MyLineNumberReader(Reader r) {
    super(r);// 父类的构造方法
  }
 
  public int getLineNumber() {
    return LineNumber;
  }
 
  public void setLineNumber(int lineNumber) {
    LineNumber = lineNumber;
  }
 
  public String readLine() throws IOException {
    this.LineNumber++;// 每读取一行，行号就增加
    return super.readLine();
  }
 
  public void close() throws IOException {
    super.close();
  }
 
}
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
 
public class LineNumberDemo {
  public static void main(String[] args) {
    MyLineNumberReader lnr = null;
 
    try {
      lnr = new MyLineNumberReader(new FileReader("F:\\ClassDemo.java"));
      String line = null;
      //lnr.setLineNumber(10);//在这里也可以自己设置行号的开始  默认的是从1开始
      while ((line = lnr.readLine()) != null) {
        System.out.println(lnr.getLineNumber()+":"+line);
      }
    } catch (FileNotFoundException e) {
      System.out.println("没有找到指定的文件");
    } catch (IOExceptione) {
      System.out.println("读取失败");
    } finally {
      if (lnr != null) {
         try {
           lnr.close();
         } catch (IOException e) {
           System.out.println("流关闭失败");
         }
      }
    }
 
  }
 
}
 
部分结果：
1:package www.fuxi.IO;
2:
3:importjava.io.FileNotFoundException;
4:import java.io.FileReader;
5:import java.io.IOException;
6:
7:public class ClassDemo {
8:  public static void main(String[]args) {

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------