利用java io 将从iteye或者csdn复制的的代码的行号去掉的

Java代码

1. package com.study.io.处理流;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileNotFoundException;  
7. import java.io.FileOutputStream;  
8. import java.io.IOException;  
9.   
10. public class BufferedReadAndBufferedWriter {  
11.     public static BufferedInputStream bfr = null;  
12.     public static BufferedOutputStream bfw = null;  
13.   
14.     public static void main(String[] args) {  
15.         try {  
16.             /** 
17.              * 定义输入和输出流,使用的最常用的BufferedReader，和BufferedWriter，因为他们有readLine()方法可用 
18.              * 需要注意的是BufferedReader，和BufferedWriter是处理流。在这里回忆下最常用节点流有:FileInputStream(OutputStream), 
19.              * FileReader(Writer),CharArrayInputStream(OutputStream),ByteArrayReader(Writer),StreamReader(Writer). 
20.              * 最常用的处理流有：BufferedReader(Writer),BufferedInputSteam(OutputStream),InputStreamReader(Writer),PrintStream,PrintWriter. 
21.              * 其中BufferedReader，和BufferedWriter 
22.              */  
23.             bfr = new BufferedInputStream(new FileInputStream(  
24.                     "f:/JavaCodeFormatter.xml"));  
25.   
26.             bfw = new BufferedOutputStream(new FileOutputStream(  
27.                     "f:/Move_num_JavaCodeFormatter.xml"));  
28.   
29.             // 在这里因为我们需要对源文件的每个字符进行判断，所以不能使用BufferedReader的readLine方法。而只能使用read()方法，一个字符一个字符的读取  
30.             int c = 0;  
31.             // n1, n2, n3, n4分别用了记录连续读取的4个字符  
32.             int n1, n2, n3, n4;  
33.               
34.             outer1:  
35.             while ((c = bfr.read()) != -1) {  
36.                 // 读取字符如果是数字  
37.                 if (c >= 48 && c <= 57) {  
38.                     n1 = c;  
39.                     // 紧接着判断下面的一个字符  
40.                     while ((n2 = bfr.read()) != -1) {  
41.                         // 如果第二个字符时数字或者点号  
42.                         if ((n2 >= 48 && n2 <= 57) || n2 == 46) {  
43.                             // 如果第二个是点  
44.                             if (n2 ==46) {  
45.                                 continue outer1;  
46.                             }  
47.                             // 如果第二个是数字  
48.                             if (n2 >= 48 && n2 <= 57) {  
49.                                 // 判断第三个  
50.                                 while ((n3 = bfr.read()) != -1) {  
51.                                     // 如果第三个字符时数字或者点号  
52.                                     if ((n3 >= 48 && n3 <= 57) || n3 == 46) {  
53.                                         // 如果第三个读取到的是点  
54.                                         if (n3 ==46) {  
55.                                             continue outer1;  
56.                                         }  
57.                                         // 如果第三个读取到的是数字  
58.                                         if (n3 >= 48 && n3 <= 57) {  
59.                                             // 判断第4个  
60.                                             while ((n4 = bfr.read()) != -1) {  
61.                                                 // 如果第4个是数字或者字符  
62.                                                 if (n4 == 46) {  
63.                                                     continue outer1;  
64.                                                 }  
65.                                                 // 第4个读取到的是点或者其他字符（除开点）  
66.                                                 else {  
67.                                                     bfw.write(n1);  
68.                                                     bfw.write(n2);  
69.                                                     bfw.write(n3);  
70.                                                     bfw.write(n4);  
71.                                                     continue outer1;  
72.                                                 }  
73.                                             }  
74.                                         }  
75.   
76.                                     }  
77.                                     // 否则读取到的第3个字符不是数字或者不是点，则将n1,n2，n3一起写入文件  
78.                                     else {  
79.                                         bfw.write(n1);  
80.                                         bfw.write(n2);  
81.                                         bfw.write(n3);  
82.                                         continue outer1;  
83.                                     }  
84.   
85.                                 }  
86.   
87.                             }  
88.                         }  
89.                         // 否则第二个读取到的第二个字符不是数字也不是点，则将n1,n2一起写入文件  
90.                         else {  
91.                             bfw.write(n1);  
92.                             bfw.write(n2);  
93.                             continue outer1;  
94.                         }  
95.                     }  
96.                 }  
97.                 // 如果不是数字，直接写入  
98.                 else {  
99.                     bfw.write(c);  
100.                 }  
101.             }  
102.   
103.         } catch (FileNotFoundException e) {  
104.             e.printStackTrace();  
105.         } catch (IOException e) {  
106.             e.printStackTrace();  
107.         } finally {  
108.             try {  
109.                 bfw.flush();  
110.                 bfr.close();  
111.                 bfw.close();  
112.             } catch (IOException e) {  
113.                 e.printStackTrace();  
114.             }  
115.         }  
116.     }  
117. }