io流。。的read机制是什么机制啊。。即便再局部内没读完。。当再次调用的时候会接着继续读。难不成是read的特有机制。。没完全读完。会接着继续读？

1. class MyStringBuffer
   
2. 
   
3. {
   
4. 
   
5.         private FileReader f;
   
6. 
   
7.         MyStringBuffer(FileReader f)
   
8. 
   
9.         {
   
10.                 this.f=f;
    
11.         }
    
12.         public String myLine() throws IOException
    
13.         {
    
14.                 StringBuilder sb=new StringBuilder();
    
15.                 int num=0;
    
16.                 while((num=f.read())!=-1)
    
17. //难不成是read的特有机制。。没完全读完。会接着继续读？
    
18.                 {
    
19.                         if(num=='\n')
    
20.                                 return sb.toString();
    
21.                         String m=sb.toString();
    
22.                         System.out.println("sb===="+sb.toString());
    
23.                         if(num=='\r')
    
24.                                 continue;
    
25.                         else
    
26.                                 sb.append((char)num);
    
27.                 }
    
28. 
    
29.                 if((sb.length())!=0)
    
30.                         return sb.toString();
    
31.                 System.out.println("sb=="+sb.toString());
    
32.                 return null;
    
33.         }
    
34.         public void myClose() throws IOException
    
35.         {
    
36.                 f.close();
    
37.         }
    
38. }
    
39. 
    
40. class Demo
    
41. {
    
42.         public static void main(String[] args)throws IOException
    
43.         {
    
44.                 FileReader fr=new FileReader("g.txt");
    
45.                 MyStringBuffer mbf=new MyStringBuffer(fr);
    
46.                 String line=null;
    
47.                 while((line=mbf.myLine())!=null)
    
48.                 {
    
49.                         System.out.println(line);
    
50.                 }
    
51.                
    
52.                 mbf.myClose();
    
53.         }
    
54. }
    
55. 
    
56. 
    
57. class Demo
    
58. {
    
59.         public static void main(String[] args)throws IOException
    
60.         {
    
61.                 FileReader fr=new FileReader("g.txt");
    
62.                 int ch=0;
    
63.                 while((ch=fr.read())!='e')
    
64.                 {
    
65.                         System.out.println((char)ch);
    
66.                 }
    
67.                 while((ch=fr.read())!=-1)
    
68.                 {
    
69.                         System.out.println((char)ch);
    
70.                 }
    
71.         }
    
72. }
    
73. read的特有机制。
    
74. 
    
75. 2.
    
76. class Demo
    
77. {
    
78.          public static void main (String[] args)throws IOException
    
79.          {
    
80.                 BufferedReader br=new BufferedReader(new FileReader("2.txt"));
    
81.                 BufferedWriter bw=new BufferedWriter(new FileWriter("12.txt"));
    
82.                 String line=null;
    
83.                 int x=0;
    
84.                 while((line=br.readLine())!=null)
    
85.                  {   
    
86.                         if(x!=0)//多个换行。
    
87.                         bw.newLine();
    
88.                         x++;
    
89.                         bw.write(line);
    
90.                         bw.flush();        
    
91.                  }
    
92.                 bw.close();
    
93.                 br.close();
    
94. 
    
95.          }
    
96. 
    
97. }

复制代码

read不是你说的特有机制， while((num=f.read())!=-1)是根据你使用的流来决定读取的方式的，字节流就是一字节一字节读，字符流就是按字符流读取即两字节一次的读；当读到文件的末尾时，会返回-1；这里不等于-1就是当文件没到末尾就一直循环读取啊

read()方法在JDK API的描述是这样的：读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。 也就是说read()方法一次读取一个字符，读到流的末尾时才结束。到达流结尾是返回-1；
Windows下的回车使用”\r\n“表示，不是应该先判断num=='\r'吗？

1. read
   
2. public int read()
   
3.          throws IOException读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
   
4. 用于支持高效的单字符输入的子类应重写此方法。
   
5. 
   
6. 
   
7. 返回：
   
8. 作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1
   
9. 抛出：
   
10. IOException - 如果发生 I/O 错误
    

复制代码

read()中有个指针，他会记录当前读指针的位置，如果读了一次没有读完，指针记录当前读取到的位置，下次再调用此方法时会从指针标记的位置开始读取

每一行的读取，如果返回值不等于-1的时候，read会 继续读取，知道到这行的最后一个字符；
然后判定num是否到了换行处，如果读到了会读取下一行。

while((num=f.read())!=-1)中read()方法一次只读一个字符，如果没读到结尾会接着上一次的位置接着读，当读到结尾时返回-1，readline()方法则是可以识别换行符，当读到换行符时这一行读取结束，返回读到的数据，返回的值不包括换行符，

read方法就是这样，一次读一个字符，下一次继续上一次的地方再读取。