今天想自己写个缓冲流玩下，当写的时候发现困难重重
最难点是你要自己实现一个缓冲池用来存放数据
而你取数据的时候是只能从缓冲池中去取出数据
缓冲的数据是纯入内存当中，这样读取缓冲数据的时候会大大提高效率
有木有大神实现了一个IO缓冲流  最主要是要实现了缓冲池的实现
求助------下面这个是我自己实现的缓冲字符流 但是只实现了readline方法

1. package test2;
   
2. 
   
3. import java.io.FileReader;
   
4. import java.io.IOException;
   
5. import java.io.InputStream;
   
6. import java.io.Reader;
   
7. 
   
8. /**
   
9. * 自定义缓冲字符流
   
10. * 难点： 如果要实现一个类似缓冲流的缓冲区  这个问题还没想透彻
    
11. * @author 李昂志
    
12. */
    
13. public class MyBufferedReader extends Reader{
    
14.         private static int bufferdSize = 9999;   //字符缓冲区原始数据量大小
    
15.         private Reader in = null;
    
16.         private char[] cs;  //用来存储字符缓冲的数据
    
17.        
    
18.         /**
    
19.          * 自定义的缓冲池
    
20.          * @param in
    
21.          * @param size
    
22.          */
    
23.         public MyBufferedReader(Reader in , int size){
    
24.                 super(in);
    
25.                 if(size<=0){
    
26.                         throw new IllegalArgumentException("Buffer size <= 0");
    
27.                 }
    
28.                 MyBufferedReader.bufferdSize = size;
    
29.                 this.in = in;
    
30.         }
    
31.         /**
    
32.          * 使用默认的缓冲池
    
33.          * @param in
    
34.          */
    
35.         public MyBufferedReader(Reader in){
    
36.                 this(in,bufferdSize);
    
37.         }
    
38.         /**
    
39.          * 此方法空实现，这个地方读取要去读取缓存池，无解中
    
40.          */
    
41.         @Override
    
42.         public int read(char[] cbuf, int off, int len) throws IOException {
    
43.                
    
44.                 return in.read(cbuf, off, len);
    
45.         }
    
46.         /**
    
47.          * 读取一行文本 ，读到换行处则 退出
    
48.          * 因为只要读取一行数据，一行数据的数据量一般较小 所以对缓冲池的要求不高 这里是模仿了老师的 完善了一点而已
    
49.          * @return 读取一行的文本 字符串
    
50.          * @throws IOException
    
51.          */
    
52.         public String readline() throws IOException{
    
53.                 StringBuilder sb = null;
    
54.                 char c ='A';
    
55.                 if(cs == null) cs = new char[bufferdSize];
    
56.                
    
57.                 int i,j =0;
    
58.                 while((i = in.read()) != -1){
    
59.                         if(sb == null){
    
60.                                 sb = new StringBuilder();
    
61.                         }
    
62.                         c = (char) i;
    
63.                         if ( c == '\r') continue;
    
64.                         if ( c == '\n') break;
    
65.                         cs[j++] = c;
    
66.                 }
    
67.                 if(sb != null ) sb.append(cs ,0 ,j);
    
68.                 else return null;
    
69.                 return sb.toString();
    
70.         }
    
71.         /**
    
72.          * 获取缓冲池大小
    
73.          * @return
    
74.          */
    
75.         public int getBufferdSize() {
    
76.                 return bufferdSize;
    
77.         }
    
78.         @Override
    
79.         public void close() throws IOException {
    
80.                 // TODO Auto-generated method stub
    
81.                 if(in != null){
    
82.                         in.close();
    
83.                 }
    
84.         }
    
85.         public static void main(String[] args) throws IOException {
    
86.                 System.out.println("----");
    
87.                 MyBufferedReader in = new MyBufferedReader(new FileReader("abc.txt"));
    
88.                 String s = null;
    
89.                 while((s = in.readline())!= null){
    
90.                         System.out.println(s);
    
91.                 }
    
92.                 in.close();
    
93.         }
    
94. }

复制代码

实际上所谓的缓冲，只不过是一个字节数组而已，或者对于Reader来说也可以用StringBuffer来缓冲

1. import java.io.IOException;
   
2. import java.io.Reader;
   
3. 
   
4. public class MyBufferedReader {
   
5.         private Reader r;
   
6. //        记录读取的行数
   
7.         private int len=0;
   
8. //        构造时要传入一个Reader对象
   
9.         MyBufferedReader(Reader r)
   
10.         {
    
11.                 this.r=r;
    
12.         }
    
13.         public int getLen() {
    
14.                 return len;
    
15.         }
    
16.         public void setLen(int len) {
    
17.                 this.len = len;
    
18.         }
    
19.         public String myReadLine() throws IOException
    
20.         {
    
21. //                在这里也可以用StringBuffer 进行存储
    
22.                 String str ="";
    
23.                 int c=0;
    
24.        
    
25.                 len++;
    
26.                 while((c=r.read())!=-1)
    
27.                 {
    
28.                        
    
29.                         if(c=='\r')
    
30.                                 continue;
    
31.                         if(c=='\n')
    
32.                                 break;
    
33.                         str+=(char)c;
    
34.                 }
    
35.                 if(str=="")
    
36.                         return null;
    
37.                 return str;
    
38.         }
    
39.         public void close() throws IOException
    
40.         {
    
41.                 r.close();
    
42.         }
    
43. }
    

复制代码

fei_xiong 发表于 2014-5-4 14:24
实际上所谓的缓冲，只不过是一个字节数组而已，或者对于Reader来说也可以用StringBuffer来缓冲
...

你这个和我的有区别么，在读取效率上恐怕比我的还低，并且你这个方法应该还存在很多问题，你读取文件看试试会不会报错..
而我所考虑的主要问题是要实现 缓冲池的实现
我们都知道 缓冲流的原理是  我们所拿到的数据是重缓冲区（也就是缓冲池）里面所获取的，你获取缓冲区的数据同时要用下标跟新，同时要保证数据的正确性.    你这个len 在这里没有任何意义

随风而去 发表于 2014-5-4 15:49
你这个和我的有区别么，在读取效率上恐怕比我的还低，并且你这个方法应该还存在很多问题，你读取文件看试 ...

感觉你写的程序没有什么问题啊！
int read(CharBuffer target)  可以直接读入的字符缓冲区！
不知道你还想实现什么功能！

ò壞尛孩 发表于 2014-5-4 17:05
感觉你写的程序没有什么问题啊！
int read(CharBuffer target)  可以直接读入的字符缓冲区！
不知道你还 ...

其实说是自定义缓存流，可其实我并没有实现缓冲流的操作
我这个数据并没有存取到内存中，基本上是每读取一次数据
就要重新去读取一次，而如果是缓冲流 ，则直接去一个已经读取好数据里面的池子里面去读取
就好如 readline 是去重内存中去读取数据 ， 而不是直接去读文本的数据
这个readline 方法 它的操作实际是这样子
文件流--- >读取文件一行（这行文件并没有存入到内存中） ---> 得到这行数据
而我想要的功能是这样子 文件流---> 读取到缓存池中 --->用 readline方法  从缓冲区读取数据 ----> 用户得到数据

随风而去 发表于 2014-5-4 17:24
其实说是自定义缓存流，可其实我并没有实现缓冲流的操作
我这个数据并没有存取到内存中，基本上是每读取 ...

你可以在readLine里面加个标记！用来记录 读取的字符长度，下次调用的时候从上次结束的位置读取
abstract  int read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
实现这个抽象方法！思路告诉你了！

ò壞尛孩 发表于 2014-5-4 17:30
你可以在readLine里面加个标记！用来记录 读取的字符长度，下次调用的时候从上次结束的位置读取
abstract  ...

呵呵，其实原理我都知道，但是实现出来有一定的困难，我看了Buffered的源代码
表示真心困难...