随笔档案

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;  //读取字符流的抽象类
 4 import java.io.IOException;
 5 /*
 6  * 自定义MyBufferedReader包装Reader,提供了一个缓冲区的功能.提供了ReadLine功能.
 7  * 1.用一个次组合,拿到被包装的Reader对象
 8  * 2.定义一个字符数组作为缓冲区
 9  * 3.实现一个read方法,填充缓冲区,从缓冲区那里返回一个字符
10  * 4.定义一个readLine方法,内部调用read方法,循环读取一行,进行返回
11  * 5.定义一个close方法,关闭地底层所包装的流
12  */
13 public class MyBufferedReader  extends Reader{
14     private Reader r;
15     char[] buf = new char[1024];
16     int len =0;
17     int pos = 0;
18     public MyBufferedReader(Reader r)
19     {
20         this.r = r;
21     }
22     /*
23      * 实现read()方法,实现缓存的功能
24      * 分析:
25      * 1.当别人第一次调用该方法的时,一次性的去填充缓冲区
26      * 2.定义一个len变量记住缓冲区的可用字符的数量
27      * 3.将数组的第一个元素返回
28      * 4.当别人第二次调用的时,将数组的二个元素返回
29      * 5.每次返回元素 len --
30      * 6.当len为零时,说明数组没有可用字符啦,那么这时候返回一个-1
31      * 
32      * 思路:
33      * 1.定义两个成员变量,len记住可用字符数量,pos记住当前字符的角标
34      * 2.判断len是否为0,如果为零要填充缓冲区.并且pos为零
35      * 3.判断len,如果为-1,则返回-1
36      * 4.将pos位置的元素返回.pos++
37      */
38     public int read() throws IOException
39     {
40         if(len ==0)
41         {
42             len = r.read(buf);
43             pos = 0;
44         }
45         if(len==-1)
46             return -1;
47         len--;
48         return buf[pos++];
49     }
50     
51     /*
52      * 实现readLine方法,实现读一行的功能,
53      * 1.循环调用自己的方法的read方法,读取字符
54      * 2.知道回车的字符,方法就结束
55      */ 
56     public String readLine() throws IOException
57     {
58         StringBuilder sb = new StringBuilder();
59         int ch;
60         while((ch=read())!=-1)
61         {
62             if(ch=='\r')
63                 continue;
64             if(ch=='\n')
65                 break;
66             sb.append((char)ch);
67             if(ch==-1&&sb.length()==0)
68                 return null;
69         }
70         return sb.toString(); //转换成字符串
71     }
72     @Override
73     public void close() throws IOException {
74         r.close();
75     }
76 
77     @Override
78     public int read(char[] cbuf, int off, int len) throws IOException {
79         int count=0;
80         for(int i=0; i<off+len; i++)
81         {
82             int ch = read();
83             if(ch==-1)
84                 break;
85             count++;
86             buf[i] = (char)ch;
87         }
88         return count;
89     }
90 
91     
92     
93 }

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Writer;
 4 
 5 public class MyBufferedWriter  extends Writer{
 6     
 7     private Writer w;
 8     private char[] buf = new char[1024];
 9     private int pos = 0;
10     
11     public MyBufferedWriter(Writer w)
12     {
13         this.w = w;
14     }
15     /*
16      * 定义Writer方法,实现写一个字符,实现缓存的功能
17      * 1.定义一个变量pos记住当前的写入位置
18      * 2.每次调用都使用这个方法都会传入一个字符,将字符缓存到数组pos位置里面去
19      * 3.pos++
20      * 4.每次上来就判断,如果pos =1024,刷新缓冲区 ,pos = 0
21      */
22     public void Writer(int ch)throws IOException
23     {
24         if(pos == 1024)
25         {
26             flush(); //刷新一下缓冲区.并且初始化为零
27             pos = 0;
28         }
29         buf[pos++] = (char)ch;
30     }
31     @Override
32     public void close() throws IOException {
33         flush();
34         w.close();
35     }
36 
37     @Override
38     public void flush() throws IOException { 
39         w.write(buf,0,pos); //把buf0-pos位置的内容写入进去
40     }
41     public void writer(String data)throws IOException
42     {
43         char[] chars = data.toCharArray(); //转换成字符
44         for(char c : chars)
45             write(c);
46     }
47     public void newline()throws IOException
48     {
49         write("\r\n"); //所谓的换行就是一个
50     }
51     @Override
52     public void write(char[] cbuf, int off, int len) throws IOException {
53         for(int i=0; i<off+len; i++)
54         {
55             w.write(buf[i]);
56         }
57         
58     }
59 
60 }

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;
 4 import java.io.Writer;
 5 public class CloseUtil {
 6     private CloseUtil(){}
 7     public static void close(Reader r,Writer w)throws IOException
 8     {
 9         try
10         {
11             if(r!=null)
12                 r.close();
13         }
14         finally
15         {
16             if(w!=null)
17             w.close();
18         }
19     }
20 }

 1 package com.javami.kudy.Code13;
 2 import java.io.FileReader;
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 public abstract class BufferedTest {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args)
12     {
13         MyBufferedReader mr = null;
14         MyBufferedWriter mw = null;
15         try
16         {
17             mr = new MyBufferedReader(new FileReader("src/a.txt"));
18             mw = new MyBufferedWriter(new FileWriter("src/b.txt"));
19             int len;
20             while((len=mr.read())!=-1)
21             {
22                 mw.Writer(len);
23             }
24         }
25         catch(IOException e)
26         {
27             e.printStackTrace();
28         }
29         finally
30         {
31             try
32             {
33                 CloseUtil.close(mr, mw);
34             }
35             catch(IOException e)
36             {
37         }
38         }
39     }
40 }