bufferedReader 缓冲作用 其实就是个数组 正常磁盘是在这读一个 在哪写一个 这样磁头会频繁的在读写转换  （那么如果把他们读到一个地址中 读很多数据后再写 这样就会省时间）
那么bufferedReader 怎么实现的呢 自己写个试试

1. public class MyBufferedReader {
   
2. 
   
3. private Reader fr = null;
   
4. 
   
5. public MyBufferedReader(Reader r) {
   
6. this.fr = r;
   
7. }
   
8. 
   
9. public String MyReadline() throws IOException {
   
10. StringBuffer sb = new StringBuffer();
    
11. int ch = 0;
    
12. while ((ch = fr.read()) != -1) {
    
13. if (ch == '\r')
    
14. continue;
    
15. if (ch == '\n') {
    
16. return sb.toString();
    
17. } else {
    
18. sb.append((char) ch);
    
19. }
    
20. 
    
21. }
    
22. if (sb.length() != 0) {
    
23. return sb.toString();
    
24. }
    
25. 
    
26. return null;
    
27. 
    
28. }
    
29. 
    
30. public void MyClose() throws IOException {
    
31. if (fr != null) {
    
32. fr.close();
    
33. }
    
34. }
    
35. 
    
36. }

复制代码

测试类

1. public class MyBufferedReaderTest {
   
2. 
   
3. public static void main(String[] args) {
   
4. 
   
5. MyBufferedReader mbr = null;
   
6. try {
   
7. mbr = new MyBufferedReader(new FileReader("d:\\star.txt"));
   
8. String str = null;
   
9. while((str = mbr.MyReadline())!=null)
   
10. {
    
11. System.out.println(str);
    
12. }
    
13. 
    
14. 
    
15. } catch (Exception e) {
    
16. e.printStackTrace();
    
17. throw new RuntimeException("读写错误");
    
18. }finally{
    
19. try {
    
20. mbr.MyClose();
    
21. } catch (IOException e) {
    
22. e.printStackTrace();
    
23. }
    
24. }
    
25. 
    
26. }
    
27. 
    
28. }

复制代码

1.bufferedreader 需要接受一个Reader的引用
2.要有readline() 与close()方法
3.StringBuffer sb = new StringBuffer();  主要实现是把字符读到一个StringBuffer中
4.\n是换行 返回sb.toSring();
5.
if (sb.length() != 0) {
return sb.toString();
}

BufferedReader类提供一套缓冲机制，在要读取文件时，首先在内存中建立一段缓冲区，然后读取文件填充满缓冲，随后对文件的操作其实是直接作用在缓冲上，当缓冲区数据读取完后，在调用read方法继续填充缓冲区，以此类推。
      首先考虑到类的创建，应该传入一个Reader对象，然后通过传入的对象进行读取等操作。而缓冲技术应该是类的内部保存着一个char型数组，将文件存入数组中，之后的操作就是作用在这个数组之上，所以我们在类中应该建立一个char型数组的私有变量，因为涉及到对数组的操作，我们应该建立length变量，存储目前数组中保存数据的长度，start变量保存目前数组操作的下标，end变量保存数组有效数据结尾的下标。考虑到文件读取结束后应该设置标志，以便停止读取文件，我设置了一个名为eof的布尔型变量，当为true时，标志文件全部读取完毕，false时当length=0时则文件应该继续读取。此类实现了 void close（）方法， String readline（）方法，int read（）方法， int read（char[] ）方法。

class MyBufferedReader{
    public MyBufferedReader(Reader fr){
       this.fr=fr;
       eof=false;
       ctr=new char[8192];
    }

    public MyBufferedReader(Reader fr,int length){
       this.fr=fr;
       eof=false;
       ctr=new char[length];
   }


   public String readline() throws IOException{
       StringBuilder sb=new StringBuilder();
       if(length==0 && !eof){
           if((length=fr.read(ctr))==-1){
               end=0;
               eof=true;
              length=0;
           }
           begin=0;
           end=length-1;
      }
      int i=begin;
      while(ctr[i]!='\n'){
          if(eof)
              return null;
          else if(length==1){
              if((length=fr.read(ctr))==-1){
                  end=0;
                  eof=true;
                  length=0;
                  if(sb.length()==0)
                      return null;
                  else
                      return sb.toString();
     
             }
             begin=0;
             end=length-1;
             i=begin;
         }  
         else if(ctr[i]=='\r'){
             i++;
             length--;
             continue;
         }
         else{
            sb.append(ctr[i++]);
            length--;
         }
     }  
     begin=++i;
     length--;
     return sb.toString();
  }


  public int read()throws IOException{
      if(length==0 && !eof){
           if((length=fr.read(ctr))==-1){
                end=0;
                eof=true;
                length=0;
           }
           end=length-1;
           begin=0;
      }
      if(length>0){
           length--;
           return ctr[begin++];   
      }  
      else
         return -1;  
  }

  public int read(char[] a) throws IOException{
       int i=0;
       if(length==0 && !eof){
            if((length=fr.read(ctr))==-1){
                end=0;
                eof=true;
                length=0;
            }
            end=length-1;
            begin=0;   
      }
      if(eof)
           return -1;
  
      else{
           for(i=0;i<a.length;i++){
                if(length>0){
                     a[i]=ctr[begin++];
                     length--;
                }
                 else{
                     if((length=fr.read(ctr))==-1){
                          end=0;
                          eof=true;
                          length=0;
                          begin=0;
                          return   i;
                     }
                     end=length-1;
                     begin=0;
                }
   
        }
        return i;
    }  
}


public void close()throws IOException{
       fr.close();
}
  private Reader fr;     //保存Reader对象
  private char[] ctr;    //缓冲区
  private boolean eof;   //文件是否读取完毕
  private int  length;   //缓冲区中有效长度
  private int  begin;    //缓冲区目前操作字符下标
  private int  end;      //缓冲区最后有效字符下标
}

BufferedReader 是通过对 Reader 的包装实现带有缓冲功能的字符读取。BufferedReader 对 数据的读取是从硬盘的文件中读取一批数据到内存中的缓冲区中，这样免去了程序对硬盘数据的频繁操作，缓冲区写满后即停止从硬盘的读取,缓冲区中的数据等 待 Java 程序的调用，Java 程序在调用缓冲区中的数据的时候，缓冲区将字符逐个返给Java程序，由于从缓冲区中读取数据的操作发生在内存中， 所以速度比较快。当缓冲区中的数据被调用完毕后，BufferedReader 开始下一次的数据的读取，缓冲区继续将数据逐个返给 Java 程序，直 到 BufferedReader 读到流末尾才停止对硬盘数据的读取，缓冲区中剩余的数据返给Java程序后即完成 了 BufferedReader 对数据的读取。