自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。
IO始终没有搞得很清楚，所以在论坛里抛出，求解题思路，不胜感激

1. import java.io.FileNotFoundException;
   
2. import java.io.FileReader;
   
3. import java.io.IOException;
   
4. import java.io.Reader;
   
5. 
   
6. public class Test {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          * @throws IOException
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14.                 //建立MyLineNumberReader对象
    
15.                 MyLineNumberReader mylnr = null;
    
16.                 try {
    
17.                         mylnr = new MyLineNumberReader(new FileReader("F:\\workspace\\exam\\src\\com\\itheima\\Test7.java"));
    
18.                         String line = null;
    
19.                         while((line=mylnr.myReadLine())!=null){
    
20.                                 System.out.println(mylnr.getLineNumber()+":"+line);
    
21.                         }
    
22.                        
    
23.                 } catch (FileNotFoundException e) {
    
24.                         // TODO Auto-generated catch block
    
25.                         e.printStackTrace();
    
26.                 } catch (IOException e) {
    
27.                         // TODO Auto-generated catch block
    
28.                         e.printStackTrace();
    
29.                 } finally{
    
30.                         try {
    
31.                                 if(mylnr!=null)
    
32.                                         mylnr.myClose();
    
33.                         } catch (IOException e) {
    
34.                                 // TODO Auto-generated catch block
    
35.                                 e.printStackTrace();
    
36.                         }
    
37.                 }
    
38.         }
    
39. 
    
40. }
    
41. 
    
42. //自定义一个字符输入流包装类,带行号
    
43. class MyLineNumberReader{
    
44.         private Reader r;
    
45.         private int lineNumber;
    
46.         MyLineNumberReader(Reader r){
    
47.                 this.r = r;
    
48.         }
    
49.        
    
50.         public String myReadLine() throws IOException{
    
51.                 lineNumber++;
    
52.                 //定义一个容器存放数据
    
53.                 StringBuilder sb = new StringBuilder();
    
54.                 int ch = 0;
    
55.                 while((ch=r.read())!=-1){
    
56.                         if(ch=='\r')
    
57.                                 continue;
    
58.                         if(!(ch=='\n'))
    
59.                                 sb.append((char)ch);
    
60.                         else
    
61.                                 return sb.toString();
    
62.                 }
    
63.                 if(sb.length()!=0)
    
64.                         return sb.toString();
    
65.                 return null;
    
66.         }
    
67.        
    
68.         //获取行号
    
69.         public int getLineNumber() {
    
70.                 return lineNumber;
    
71.         }
    
72. 
    
73.         //设置行号
    
74.         public void setLineNumber(int lineNumber) {
    
75.                 this.lineNumber = lineNumber;
    
76.         }
    
77. 
    
78.         //关闭流
    
79.         public void myClose() throws IOException{
    
80.                 r.close();
    
81.         }
    
82. }

复制代码

import  java.io.*;
class MyLineNumberReader
{
       private Reader r;
       int lineNum=0;      
       MyLineNumberReader( Reader r )
       {
              this.r=r;
              lineNum=0;
       }
       public String readLine() throws Exception
       {
              StringBuffer sb=new StringBuffer();
              int num=0;
              while( (num=r.read())!=-1 )
              {
                     if( num=='\r')
                            continue;
                     else if( num=='\n')
                     {
                            lineNum++;
                            return addLineNum( sb.toString() );            
                     }
                     else
                     {
                            sb.append((char)num);
                     }              
              }
              if( sb.length()>0 )
              {
                     return sb.toString();
              }
              return null;
       }
  
       public String addLineNum( String s )
       {
              return lineNum+": "+s;
       }
       public void close() throws Exception
       {
              r.close();
       }
}

class Demo
{
       public static void main(String args[]) throws Exception
       {
              MyLineNumberReader my=new MyLineNumberReader( new FileReader("upLoadTxt.java"));
              String s=null;
              while( (s=my.readLine())!=null )
              {
                     System.out.println( s );
              }
       }
}

下面是我写的完整的代码，注释写的应该很详细，仅供参考，希望对你有帮助
import java.io.FileReader;
import java.io.IOException;
//自定义的包装类
public class MyBufferedReader {
        private FileReader r;
        //read()是FileReader类的方法，所以一初始化就让一个流对象进来。
        public MyBufferedReader(FileReader r){
                this.r=r;
        }
        //行号从1开始
        private int num=1;
        //自定义readLine方法，一次读取一行。
        public String myReadLine(){
                //定义一个StringBuilder临时容器，因为最后要把数据变成字符串。
                StringBuilder sb=new StringBuilder();
                int ch=0;
                try {
                        while((ch=r.read())!=-1){
                                //如果是每行的开头，并且不是\r和\n，就在前面加上行号和冒号
                                if(sb.length()==0&&ch!='\r'&&ch!='\n')
                                        System.out.print(num+++":");
                                //如果读到\r，不存到StringBuilder中，继续读.
                                if(ch=='\r')
                                        continue;
                                //如果读到\n，说明读到行结尾，把缓冲区中数据返回。
                                if(ch=='\n')
                                        return sb.toString();
                                //既不是\r也不是\n，读一个就往缓冲区中存一个
                                else
                                        sb.append((char)ch);
                        }
                        //如果缓冲区中有数据
                        if(sb.length()!=0){
                                //把缓冲区数据返回
                                return sb.toString();
                        }
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                //如果读到结尾，返回空
                return null;
        }
        //自定义close方法，关闭资源。
        public void myClose(){
                try {
                        r.close();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}

public class Test{
        public static void main(String[] args) {
                FileReader fr=null;
                MyBufferedReader mbr=null;
                try {
                        fr = new FileReader("testsix.txt");
                        //初始化就传入一个流对象
                        mbr=new MyBufferedReader(fr);
                        String line=null;
                        //调用自定义的myReadLine方法
                        while((line=mbr.myReadLine())!=null){
                                System.out.println(line);
                        }
                } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }finally{
                        //调用自定义的myClose方法，关闭资源。
                        mbr.myClose();
                }
        }
}

make a mark