/*
要求：自定义字节流中的缓冲区
思路：
1，
*/
import java.io.*;
class Huanchongqu
{
        public static void main(String[] args) throws Exception
        {
                MyBufferedInputStream bi=new MyBufferedInputStream(new FileInputStream("ga.jpg"));
                BufferedOutputStream in=new BufferedOutputStream(new FileOutputStream("ha.jpg"));
                int num=0;
                while((num=bi.myread())!=-1)
                {
                        in.write(num);
                }
        }
}
class MyBufferedInputStream
{
        private FileInputStream in;
        MyBufferedInputStream(FileInputStream in)
        {
                this.in=in;
        }
        byte[] arr=new byte[1024];
        int pos=0;
        int count=0;
        public int myread()throws Exception
        {
                if(count==0)
                {
                        pos=0;
                        count=in.read(arr);
                        count--;
                        return arr[0]&255;//  此处是强转，将byte型转换为int型，在将
                }
                if(count>0)
                {
                        pos++;
                        count--;
                        return arr[pos]&255;
                }
                return -1;
        }
}

问题解决了就把类型改成提问结束1

看了好久，终于发现你的2处错误，第一是没刷新，第二是返回有问题。给你在代码中作了注释，你看看就懂了。

1. import java.io.*;
   
2. class Huanchongqu
   
3. {
   
4.         public static void main(String[] args) throws Exception
   
5.         {
   
6.                 MyBufferedInputStream bi=new MyBufferedInputStream(new FileInputStream("ga.jpg"));
   
7.                 BufferedOutputStream in=new BufferedOutputStream(new FileOutputStream("ha.jpg"));
   
8.                 int num=0;
   
9.                 while((num=bi.myread())!=-1)
   
10.                 {
    
11.                         in.write(num);
    
12.                         in.flush();    /*没刷新，找了好久，经过测试发现这个系统自定义的字节数组大小是64k,
    
13.                                       和udp协议传输的最大包一样大，你传个小于64k的图片就不会丢失数据。
    
14.                                     所以当超过64k后会继续往里面添加内容，就会覆盖前面的一些数据。
    
15.                                 据我估计，当覆盖的数据超过一定大小，会自动刷新一次，所以每次复制都会变少。*/
    
16.                 }
    
17.                                 in.close();  //最好关流，习惯成自然
    
18.         }
    
19. }
    
20. class MyBufferedInputStream
    
21. {
    
22.         private FileInputStream in;
    
23.         MyBufferedInputStream(FileInputStream in)
    
24.         {
    
25.                 this.in=in;
    
26.         }
    
27.         byte[] arr=new byte[1024];
    
28.         int pos=0;
    
29.         int count=0;
    
30.         public int myread()throws Exception
    
31.         {
    
32.                 if(count==0)
    
33.                 {
    
34.                         pos=0;
    
35.                         count=in.read(arr);
    
36.                         if(count==-1)    //这里少了两局话，当没有数据后count=-1,
    
37.                                         //然后count-- return -2 & 255 , 多出了一个字节
    
38.                              return -1;
    
39.                         count--;
    
40.                         return arr[0]&255;//  此处是强转，将byte型转换为int型，在将
    
41.                 }
    
42.                 if(count>0)
    
43.                 {
    
44.                         pos++;
    
45.                         count--;
    
46.                         return arr[pos]&255;
    
47.                 }
    
48.                 return -1;
    
49.         }
    
50. }

复制代码