代码如下：

package com.joe.io;

import java.io.IOException;

import java.io.InputStream;

public class MyBufferedInputStream {

        private InputStream in;

        private byte[] buf = new byte[1024];

        private int pos = 0, count = 0;

        public MyBufferedInputStream() {

                this.in = in;

        }

        // 一次读一个字节，从缓冲区（字节数组）获取。

        public int myRead() throws IOException {

                // 通过in对象读取硬盘上数据，并存储buf中

                if (count == 0) {

                        count = in.read(buf);                 //count 代表的是计数器  count = in.read（buf）的意思是？

                        if(count<0)

                                return -1;

                        pos = 0;

                        byte b = buf[pos];

                        count--;

                        pos++;

                        return b;

                }

                else if (count > 0) {

                        byte b = buf[pos];

                        count--;

                        pos++;

                        return b;

                }

                return -1;

        }

        public void myClose() throws IOException {

                in.close();

        }

}

主要不太懂myRead()这个方法，感觉顺序有点乱，有谁可以帮我解答下吗？每一行的代码的意思。

我也看不懂啊。。。。

micro_hx 发表于 2015-7-19 10:33
我也看不懂啊。。。。

你开始上课了么？

joe520kay 发表于 2015-7-19 10:46
你开始上课了么？

在家看呢？？？这不暑假吗，好好看看

micro_hx 发表于 2015-7-20 00:40
在家看呢？？？这不暑假吗，好好看看

你技术分拿了多久才到25呀?

1.   public int myRead() throws IOException {
   
2.             // 通过in对象读取硬盘上数据，并存储buf中
   
3.             if (count == 0) {
   
4.                     count = in.read(buf);    // count表示字节流一次从文件中读取的字节数
   
5.                     if(count<0)                                // 如果已经读到结尾，再读就会小于0，返回-1
   
6.                             return -1;
   
7.                     pos = 0;                                // 将pos置为0，目的：每次从文件中读取一批数据，都从0角标开始取
   
8.                     byte b = buf[pos];               
   
9. 
   
10.                     count--;                                // 读一次，计数器count减去1
    
11.                     pos++;                                        // 读一次，位置加1
    
12.                     return b;                                // 将读取到的数据返回给调用者
    
13.             }
    
14. 
    
15.             else if (count > 0) {                        // 当计数器大于0的时候不用从文件中再取数据
    
16.                     byte b = buf[pos];
    
17. 
    
18.                     count--;
    
19.                     pos++;
    
20.                     return b;
    
21.             }
    
22.             return -1;
    
23.     }

复制代码

是不是这个意思

Matrix_heima 发表于 2015-7-20 11:32
是不是这个意思

其实我有点不懂为什么if(count<0)会在if（count==0）内部，这不是有点冲突吗？还有就是count = in.read(buf)这个表示字节数，是指计数器自减到0时，才有读的动作吗？

joe520kay 发表于 2015-7-21 10:36
其实我有点不懂为什么if(count

开始读的时候肯定是0，需要先读取一批数据（用count = in.read(buf)）到buffer中。然后就可以使用buffer中的数据。每调用一次位置（pos）+1，计数器（count）-1。当缓存中有数据（if (count > 0)）就不用再读取，直接使用，当然每调用一次位置（pos）+1，计数器（count）-1。当计数器（count）减到0时，说明buffer中的数据没了，需要再取一批。依次循环。当读到文件结尾部分时，再取数据没有了，这时count就是-1。返回即可。
if(count<0)在if（count==0）内。
只有读取数据的时候才知道是否还有数据，即在count=0的基础上，才能判断count是否小于0
count = in.read(buf)这个表示字节数，是指计数器自减到0时，才有读的动作吗
是的
------------------------------------
大概就是这个意思

1.       public int myRead() throws IOException {
   
2.                 // 通过in对象读取硬盘上数据，并存储buf中
   
3.                 if (count == 0) {
   
4.                         count = in.read(buf);    // count表示字节流一次从文件中读取的字节数
   
5.                         if(count<0)                                // 如果已经读到结尾，再读就会小于0，返回-1
   
6.                                 return -1;
   
7.                         pos = 0;                                // 将pos置为0，目的：每次从文件中读取一批数据，都从0角标开始取
   
8.                         byte b = buf[pos];               
   
9. 
   
10.                         count--;                                // 读一次，计数器count减去1
    
11.                         pos++;                                        // 读一次，位置加1
    
12.                         return b;                                // 将读取到的数据返回给调用者
    
13.                 }
    
14. 
    
15.                 else if (count > 0) {                        // 当计数器大于0的时候不用从文件中再取数据
    
16.                         byte b = buf[pos];
    
17. 
    
18.                         count--;
    
19.                         pos++;
    
20.                         return b;
    
21.                 }
    
22.                 return -1;
    
23.         }

复制代码

关键是要知道什么时候什么情况下才会走05行的代码，你可以在05行下面插入一个打印语句，然后你试试新建一个空的txt文件，用这个代码去读这个空的txt文件，你会发现这行打印语句代码就执行到了。
结果就是：

1.       public int myRead() throws IOException {
   
2.                 // 通过in对象读取硬盘上数据，并存储buf中
   
3.                 if (count == 0) {
   
4.                         count = in.read(buf);    // count表示字节流一次从文件中读取的字节数
   
5.                         if(count<0){                                // 如果已经读到结尾，再读就会小于0，返回-1
   
6.                                 System.out.println("我被执行到了！");
   
7.                                 return -1;
   
8.                         }
   
9.                         pos = 0;                                // 将pos置为0，目的：每次从文件中读取一批数据，都从0角标开始取
   
10.                         byte b = buf[pos];               
    
11. 
    
12.                         count--;                                // 读一次，计数器count减去1
    
13.                         pos++;                                        // 读一次，位置加1
    
14.                         return b;                                // 将读取到的数据返回给调用者
    
15.                 }
    
16. 
    
17.                 else if (count > 0) {                        // 当计数器大于0的时候不用从文件中再取数据
    
18.                         byte b = buf[pos];
    
19. 
    
20.                         count--;
    
21.                         pos++;
    
22.                         return b;
    
23.                 }
    
24.                 return -1;
    
25.         }

复制代码

也就是说，这里的判断是为了拷贝一个空文件而存在的！
不懂可以继续问。

第一个问题：count = in.read（buf）。表示通过in的read方法去读取数据，并将数据存放在buf中，而返回读取了多大的数据，也就是用了数组的多少。最大数组不就是1024么，这个值主要是用来记录最后一次读取不满1024的情况，可以直接用这个值作为添加这么多数据，不至于添加了null