int buffsize=1024;                                                           
     FileInputStream fis= null;                                                                                                                                                                                   
     BufferedInputStream bis = null;                                                                          
     try                                                                                                      
     {                                                                                                        
     synchronized (socket.getOutputStream())                                                                
          {                                                                                                    
          OutputStream os=socket.getOutputStream();                                                          
     byte [] temp=pack.handlePack(socket);                                                                
     if(ackcode!=0)                                                                                       
     {                                                                                                    
     os.write(temp);                                                                                    
     os.flush();                                                                                        
     return;                                                                                            
     }                                                                                                    
     byte [] buffer=new byte[buffsize];                                                                   
     fis=new FileInputStream(file);                                                                       
     System.out.println("offset:" + offset);                                                              
     fis.skip(offset);                                                                                                                                                                                   
     bis=new BufferedInputStream(fis);                                                                    
     int length;                                                                                          
     if(offset==0)                                                                                        
     {                                                                                                    
         byte []data=new byte [buffsize-temp.length];                                                       
         length=bis.read(data);                                                                           
         System.arraycopy(temp,0,buffer,0,temp.length);                                                   
         System.arraycopy(data,0,buffer,temp.length,length);                                               
         os.write(buffer,0,temp.length+length);                                                           
     }                                                                                                    
         length=0;                                                                                          
        while((length=bis.read(buffer))!=-1)                                                                                                                                            
             {                                                                                                                                                                                                
          os.write(buffer, 0, length);                                                                     
              }                                                                                                                                   
                os.flush();                                                                                      
                } 
                            }
这是公司前辈的一段代码,handlePack()返回的是一段byte数组信息,offset指的是偏移量,length=bis.read(data);输入流读到的不一定是文件的全部,
 os.write(buffer,0,temp.length+length);当数组拷贝的时候,不一定把全部的字节用输出流输出。所以需要 while((length=bis.read(buffer))!=-1)                                                                                                                                            
             {                                                                                                                                                                                                
          os.write(buffer, 0, length);                                                                     
              }   这段代码,把没有读完的文件的字节用输出流输出
我的问题是输出流中的write(byte[] b,int off,int len),将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 while((length=bis.read(buffer))!=-1)                                                                                                                                            
             {                                                                                                                                                                                                
          os.write(buffer, 0, length);                                                                     
              }   那么这段岂不是读的不是完整的文件,因为 System.arraycopy(data,0,buffer,temp.length,length); 只有这么多字节length=bis.read(buffer))在buffer中
但实际上输出量最后输出的是完整的字节,是不是第一次os.write没有flush,导致了下面的边读边写可以接着buffer数组的后面进行字节的输出的操作?
希望我能表达清楚我的意思

解决方案 »

  1.   

    fis = new FileInputStream(file);
            System.out.println("offset:" + offset);
            fis.skip(offset);
            bis = new BufferedInputStream(fis);
            int length;
            if (offset == 0) {
                byte[] data = new byte[buffsize - temp.length];
                length = bis.read(data);
                System.arraycopy(temp, 0, buffer, 0, temp.length);
                System.arraycopy(data, 0, buffer, temp.length, length);
                os.write(buffer, 0, temp.length + length);
            }
    =======================================
    这一步应该是发送给对方的一个确认信息,并没有发送整个文件的意思。
    如果没有设置偏移数据,需要发送temp+文件头部的一段数据。最长为1024,读出来的时候,减去了temp长度。
    即:没有偏移设置的时候,第一个1024个数据,包含了temp数据。
      

  2.   

    System.arraycopy(data,0,buffer,temp.length,length); ==============================
    这一句,你应该理解错了,把data中的数据,为0开始复制到buffer数组中,因为buffer数组中已经有了temp数组数据,所以从temp长度后加上data的数据,是正确的。
    即:buffer数组中包含temp[]data[]两个数组数据拼接的。
      

  3.   

    但实际上输出量最后输出的是完整的字节,是不是第一次os.write没有flush,导致了下面的边读边写可以接着buffer数组的后面进行字节的输出的操作?
    ================================
    第一次加不加flush没有什么影响,可加可不加,最好加上。
      

  4.   


    buffer数组中包含temp[]data[]两个数组数据拼接的,下面这段代码while((length=bis.read(buffer))!=-1)                                                                                                                                            
                            {                                                                                                                                                                                                   
                                os.write(buffer, 0, length);                                                                     
                             }  
    bis文件输入流读的是现有的buffer数组信息,但是buffer数组里面文件的字节流是不全的,这样没有办法输出全部文件的信息啊?请指教
      

  5.   

    buffer其实就是一个桶,往桶里加满了,你把桶领走。
      

  6.   

    真没有明白森么意思,如果只是IO的操作java有很好的封装,基本上都可以很快上手
      

  7.   


    =================================
    上面的代码读出的文件信息是全的。因为我只能发三个信息,第四个信息取消了。
    以上的代码在项目中肯定是不符合规范的,通信要组织协议,要确认整个通信中的正确性和稳定性。
    你的代码顶多只了解socket的人写的,去看mina框架吧,我在项目中一般都自己写,最近也在看mina源码。
    不过你不需要去读源码,会用就行,除非你有那个追求。