1. import java.io.*;
   
2. class MyBufferedReader
   
3. {
   
4.         private FileReader r;
   
5.         MyBufferedReader(FileReader r)
   
6.         {
   
7.                 this.r=r;
   
8.         }
   
9.         public String myReadLine() throws IOException
   
10.         {
    
11.                 StringBuilder sb=new StringBuilder();
    
12.                 int ch=0;
    
13.                 while((ch=r.read())!=-1)
    
14.                 {
    
15.                         if(ch=='\t')
    
16.                                 continue;
    
17.                         else if(ch=='\n')
    
18.                                 return sb.toString();  //在这个循环中sb一直在接受值怎么做到一行一行打印的？？
    
19.                         else
    
20.                                 sb.append((char)ch);  //如果是用主函数的while循环来控制的话，sb应该也是累加的，为什么
    
21.                 }                                                                //sb接受一行字符之后又把前面的字符给清掉了？？？？
    
22.                 if(sb.length()!=0)
    
23.                         return sb.toString();
    
24.                 return null;
    
25.         }
    
26.         public void myClose() throws IOException
    
27.         {
    
28.                 r.close();
    
29.         }
    
30. }
    
31. class MyBufferedReaderDemo
    
32. {
    
33.         public static void main(String[] args) throws IOException
    
34.         {
    
35.                 FileReader fr=new FileReader("Demo.java");
    
36.                 MyBufferedReader mybuf=new MyBufferedReader(fr);
    
37.                 String line=null;
    
38.                 while((line=mybuf.myReadLine())!=null)
    
39.                 {
    
40.                         System.out.println(line);
    
41.                 }
    
42.                 mybuf.myClose();
    
43.         }
    
44. }

复制代码

问题在代码中写出来了，现在我是bug在这了，想不出为什么了，有点专牛角尖了

周之浩 发表于 2013-7-19 12:23
主函数在判断时不就是调用定义的函数吗

我想通了，因为在执行过程中流并没有关闭，虽然重新执行函数但是r.read()一直都是一个流，只是有了循环以后就可以中途停止

周之浩 发表于 2013-7-19 12:23
主函数在判断时不就是调用定义的函数吗

第一行字符串传给line后，主函数再判断，接着mybuf调用函数，sb是被重新建立了，但是方法为什么就从第二行开始取数据了？你能说一下函数执行的流程吗？

水。。。海 发表于 2013-7-19 12:01
照你的说法读一行后函数结束，主函数判断真假再执行输出语句，然后循环怎么又跳到函数处？ ...

主函数在判断时不就是调用定义的函数吗

周之浩 发表于 2013-7-19 11:44
哥们你想搞懂你的问题，主要是的明确你定义的函数的执行流程，我在你的代码中写了你的疑惑的地方，很简略， ...

照你的说法读一行后函数结束，主函数判断真假再执行输出语句，然后循环怎么又跳到函数处？

1. package com.zh.io;
   
2. 
   
3. import java.io.*;
   
4. class MyBufferedReader
   
5. {
   
6.         private FileReader r;
   
7.         MyBufferedReader(FileReader r)
   
8.         {
   
9.                 this.r=r;
   
10.         }
    
11.         public String myReadLine() throws IOException
    
12.         {
    
13.                 StringBuilder sb=new StringBuilder();
    
14.                 int ch=0;
    
15.                 while((ch=r.read())!=-1)
    
16.                 {
    
17.                         if(ch=='\t')
    
18.                                 continue;
    
19.                         else if(ch=='\n')
    
20.                                 return sb.toString();  //在这个循环中sb一直在接受值怎么做到一行一行打印的？？
    
21.                                                        //在这儿，函数读到回车换行，函数就会结束，返回String字符串对象
    
22.                         else
    
23.                                 sb.append((char)ch);  //如果是用主函数的while循环来控制的话，sb应该也是累加的，为什么
    
24.                                                         //sb接受一行字符之后又把前面的字符给清掉了？？？？
    
25.                                                       //一个字符一个字符的读入StringBuilder对象中，当时当函数执行结束后，函数会重新创建一个StringBuilder的对象
    
26.                 }                                                               
    
27.                 if(sb.length()!=0)
    
28.                         return sb.toString();
    
29.                 return null;
    
30.         }
    
31.         public void myClose() throws IOException
    
32.         {
    
33.                 r.close();
    
34.         }
    
35. }
    
36. public class MyBufferedReaderDemo
    
37. {
    
38.         public static void main(String[] args) throws IOException
    
39.         {
    
40.                 FileReader fr=new FileReader("DataStream.java");
    
41.                 MyBufferedReader mybuf=new MyBufferedReader(fr);
    
42.                 String line=null;
    
43.                 while((line=mybuf.myReadLine())!=null)
    
44.                 {
    
45.                         System.out.println(line);
    
46.                 }
    
47.                 mybuf.myClose();
    
48.         }
    
49. }

复制代码

哥们你想搞懂你的问题，主要是的明确你定义的函数的执行流程，我在你的代码中写了你的疑惑的地方，很简略，希望能给你点提示，对你思考有一定的指引

每一次调用 ReadLine方法不是StringBuilder sb=new StringBuilder();又重新创建了一个sb吗？