文件转换为字节数组的三种方式。

将文件转换为字节数组的io处理

文件转字节数组处理方式

1. 传统io处理，应该比单纯nio还要快但是线程阻塞。
2. nio处理方式，只是异步，并没有提高性能。
3. 利用MappedByteBuffer 实现处理大文件提升性能。

package test;
import java.io.BufferedInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
import java.io.RandomAccessFile;  
import java.nio.ByteBuffer;  
import java.nio.MappedByteBuffer;  
import java.nio.channels.FileChannel;  
import java.nio.channels.FileChannel.MapMode;  
 
 
public class FileUtils {  
 
   /** 
    * the traditional io way  
    * @param filename 
    * @return 
    * @throws IOException 
    */  
   public static byte[] toByteArray(String filename) throws IOException{  
         
       File f = new File(filename);  
       if(!f.exists()){  
           throw new FileNotFoundException(filename);  
       }  
       //此处出现问题当文件大于1.9G 数组装不下.
       ByteArrayOutputStream bos = new ByteArrayOutputStream((int)f.length());  
       BufferedInputStream in = null;  
       try{  
           in = new BufferedInputStream(new FileInputStream(f));  
           int buf_size = 1024;  
           byte[] buffer = new byte[buf_size];  
           int len = 0;  
           while(-1 != (len = in.read(buffer,0,buf_size))){  
               bos.write(buffer,0,len);  
           }  
           return bos.toByteArray();  
       }catch (IOException e) {  
           e.printStackTrace();  
           throw e;  
       }finally{  
           try{  
               in.close();  
           }catch (IOException e) {  
               e.printStackTrace();  
           }  
           bos.close();  
       }  
   }  
     
     
   /** 
    * NIO way 
    * @param filename 
    * @return 
    * @throws IOException 
    */  
   public static byte[] toByteArray2(String filename)throws IOException{  
         
       File f = new File(filename);  
       if(!f.exists()){  
           throw new FileNotFoundException(filename);  
       }  
         
       FileChannel channel = null;  
       FileInputStream fs = null;  
       try{  
           fs = new FileInputStream(f);  
           channel = fs.getChannel(); 
         //此处出现问题当文件大于1.9G 数组装不下.
           ByteBuffer byteBuffer = ByteBuffer.allocate((int)channel.size());  
           while((channel.read(byteBuffer)) > 0){  
               // do nothing  
//              System.out.println("reading");  
           }  
           return byteBuffer.array();  
       }catch (IOException e) {  
           e.printStackTrace();  
           throw e;  
       }finally{  
           try{  
               channel.close();  
           }catch (IOException e) {  
               e.printStackTrace();  
           }  
           try{  
               fs.close();  
           }catch (IOException e) {  
               e.printStackTrace();  
           }  
       }  
   }  
     
     
   /** 
    * Mapped File  way 
    * 可以在处理大文件时，提升性能 
    * @param filename 
    * @return 
    * @throws IOException 
    */  
   public static byte[] toByteArray3(String filename)throws IOException{  
         
       FileChannel fc = null;  
       try{  
           fc = new RandomAccessFile(filename,"r").getChannel();  
           MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size()).load();  
           System.out.println(byteBuffer.isLoaded()); 
         //此处出现问题当文件大于1.9G 数组装不下.
           byte[] result = new byte[(int)fc.size()];  
           if (byteBuffer.remaining() > 0) {  
//              System.out.println("remain");  
               byteBuffer.get(result, 0, byteBuffer.remaining());  
           }  
           return result;  
       }catch (IOException e) {  
           e.printStackTrace();  
           throw e;  
       }finally{  
           try{  
               fc.close();  
           }catch (IOException e) {  
               e.printStackTrace();  
           }  
       }  
   }  
}