readline方法的内部是怎样实现读一行的？？？？？？

上面那个帅气的冬瓜已经很能说明问题了，但冬瓜在帅能是什么样？

这个 或许可以。

1. Int 随机数 = 随机数；
   
2. int i= 0；
   
3. while（readline）｛
   
4. i++;
   
5. if(i == 随机数)｛
   
6.   取这一行的内容输出
   
7. ｝
   
8. ｝

复制代码

首先你得有一个缓冲器，也就是new一个字节数组，你这个字节数组得足够装下一行的字节数，然后就把一行里面的字节一个一个往数组里读，当读到换行“\r\n”的时候，就停止读了。这就是readline方法的原理，毕老师视频有讲的！好好看

就是把读取一个字符的方法循环了，当碰到回车符的时候，就把这一行刷新出去。也就是说他还是在一个字符一个字符的读，以回车符作为标记，把标记前面的存到定义好的空间当中，把他以字符串的形式反给你，上面这哥们写的已经很给力了。

这个原理在毕老师的课程中有讲过，我把源码附上，源码中有注释，您看一下就应该明白了

1. import java.io.FileReader;
   
2. import java.io.IOException;
   
3. 
   
4. /*
   
5. * BufferedReader读取流对象缓冲区中readLine()的原理实现
   
6. * readLine()底层用的其实还是read，而关闭缓冲区底层用的其实是关闭流对象
   
7. * readLine()，将换行符和回车符以外的字符返回到缓冲区，满一行则返回本行字符
   
8. * 如果判断满一行：
   
9. * windows中换行：\r\n
   
10. * Linux中换行：\n
    
11. * 为了实现跨平台，若碰到\r的时候，继续读取下一个字符，若\n则返回字符串
    
12. */
    
13. public class ReadLineMethodPrinciple {
    
14. 
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 // TODO Auto-generated method stub
    
18.                 MyBufferedReader mbuf = null;
    
19.                 try
    
20.                 {
    
21.                         mbuf = new MyBufferedReader(new FileReader("DateTest.java"));
    
22.                         String line = "";
    
23.                         while((line=mbuf.myReadLine())!=null)
    
24.                         {
    
25.                                 sop(line);
    
26.                         }
    
27.                 }
    
28.                 catch(IOException e)
    
29.                 {
    
30.                         throw new RuntimeException("文件读取失败");
    
31.                 }
    
32.                 finally
    
33.                 {
    
34.                         try
    
35.                         {
    
36.                                 if(mbuf!=null)
    
37.                                         mbuf.myClose();
    
38.                         }
    
39.                         catch (IOException e)
    
40.                         {
    
41.                                 throw new RuntimeException("文件关闭失败");
    
42.                         }
    
43.                 }
    
44.                
    
45.                
    
46.                
    
47.         }
    
48.         public static void sop(Object obj)
    
49.         {
    
50.                 System.out.println(obj);
    
51.         }
    
52. 
    
53. }
    
54. class MyBufferedReader
    
55. {
    
56.         private FileReader r = null;
    
57.         MyBufferedReader(FileReader r)
    
58.         {
    
59.                 this.r = r;
    
60.         }
    
61.         public String myReadLine() throws IOException
    
62.         {
    
63.                 StringBuilder sb = new StringBuilder();
    
64.                 int ch = 0;
    
65.                 while((ch=r.read())!=-1)
    
66.                 {
    
67.                         if(ch=='\r')
    
68.                                 continue;
    
69.                         if(ch=='\n') //遇到\n返回字符串
    
70.                                 return sb.toString();
    
71.                         sb.append((char)ch); //将字符存入字符串缓冲区
    
72.                 }
    
73.                 if(sb.length()!=0)   //这个判断是为了最后一行没有换行标记的情况下返回本行字符
    
74.                         return sb.toString();
    
75.                 return null;
    
76.         }
    
77.         public void myClose() throws IOException
    
78.         {
    
79.                 r.close();
    
80.         }
    
81. }

复制代码

这个原理毕老师讲过了的，就是用与缓冲区关联的流对象的read方法读取数据，但是不是立即处理数据，而是先将数据存储在一个临时容器中（例如StringBuilder），等读到回车标记时将临时容器中的数据一次性返回。

应该是先申请一个char类型的数组或者StringBuilder，然后循环readByte返回byte，循环条件是是否读取到newLine();
读到了就直接返回数组。。转换成String

哥们  是这样的   不懂的话再问！只先写个方法：import java.io.*;
class newBuffRea
{
       private FileReader r;
     newBufRea(FileReader r){
     this.r=r;
       }
}
public  String newReLi() throws IOException{
        StringBuild sb=new StringBuild();//这里是定义一个临时容器
        int ch=0;
        while((ch=r.read())!=-1)//当读到的一行有值时，r是本类对象。
        {
               if(ch=='\r')//当遇到回车时，继续读取数据。
                    comtinue;
               if(ch=='\n')//当遇到换行符是，返回这一行的字符串
                    return sb.toString();
               else
                    sb.append((char)ch);//如果没有遇到换行符，把读到的添加到容器里面
          }
                 if (sb.length()!=0)//当容器里面有数据时
                        return sb.toString();// 返回字符串
                return null;
}