读取Java文件到byte数组的三种方式

1. 代码如下
2. 
   
3. import java.io.BufferedInputStream;  
4. import java.io.ByteArrayOutputStream;  
5. import java.io.File;  
6. import java.io.FileInputStream;  
7. import java.io.FileNotFoundException;  
8. import java.io.IOException;  
9. import java.io.RandomAccessFile;  
10. import java.nio.ByteBuffer;  
11. import java.nio.MappedByteBuffer;  
12. import java.nio.channels.FileChannel;  
13. import java.nio.channels.FileChannel.MapMode;  
14.   
15.   
16. public class FileUtils {  
17.   
18.     /** 
19.      * the traditional io way  
20.      * @param filename 
21.      * @return 
22.      * @throws IOException 
23.      */  
24.     public static byte[] toByteArray(String filename) throws IOException{  
25.           
26.         File f = new File(filename);  
27.         if(!f.exists()){  
28.             throw new FileNotFoundException(filename);  
29.         }  
30.   
31.         ByteArrayOutputStream bos = new ByteArrayOutputStream((int)f.length());  
32.         BufferedInputStream in = null;  
33.         try{  
34.             in = new BufferedInputStream(new FileInputStream(f));  
35.             int buf_size = 1024;  
36.             byte[] buffer = new byte[buf_size];  
37.             int len = 0;  
38.             while(-1 != (len = in.read(buffer,0,buf_size))){  
39.                 bos.write(buffer,0,len);  
40.             }  
41.             return bos.toByteArray();  
42.         }catch (IOException e) {  
43.             e.printStackTrace();  
44.             throw e;  
45.         }finally{  
46.             try{  
47.                 in.close();  
48.             }catch (IOException e) {  
49.                 e.printStackTrace();  
50.             }  
51.             bos.close();  
52.         }  
53.     }  
54.       
55.       
56.     /** 
57.      * NIO way 
58.      * @param filename 
59.      * @return 
60.      * @throws IOException 
61.      */  
62.     public static byte[] toByteArray2(String filename)throws IOException{  
63.           
64.         File f = new File(filename);  
65.         if(!f.exists()){  
66.             throw new FileNotFoundException(filename);  
67.         }  
68.           
69.         FileChannel channel = null;  
70.         FileInputStream fs = null;  
71.         try{  
72.             fs = new FileInputStream(f);  
73.             channel = fs.getChannel();  
74.             ByteBuffer byteBuffer = ByteBuffer.allocate((int)channel.size());  
75.             while((channel.read(byteBuffer)) > 0){  
76.                 // do nothing  
77. //              System.out.println("reading");  
78.             }  
79.             return byteBuffer.array();  
80.         }catch (IOException e) {  
81.             e.printStackTrace();  
82.             throw e;  
83.         }finally{  
84.             try{  
85.                 channel.close();  
86.             }catch (IOException e) {  
87.                 e.printStackTrace();  
88.             }  
89.             try{  
90.                 fs.close();  
91.             }catch (IOException e) {  
92.                 e.printStackTrace();  
93.             }  
94.         }  
95.     }  
96.       
97.       
98.     /** 
99.      * Mapped File  way 
100.      * MappedByteBuffer 可以在处理大文件时，提升性能 
101.      * @param filename 
102.      * @return 
103.      * @throws IOException 
104.      */  
105.     public static byte[] toByteArray3(String filename)throws IOException{  
106.           
107.         FileChannel fc = null;  
108.         try{  
109.             fc = new RandomAccessFile(filename,"r").getChannel();  
110.             MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size()).load();  
111.             System.out.println(byteBuffer.isLoaded());  
112.             byte[] result = new byte[(int)fc.size()];  
113.             if (byteBuffer.remaining() > 0) {  
114. //              System.out.println("remain");  
115.                 byteBuffer.get(result, 0, byteBuffer.remaining());  
116.             }  
117.             return result;  
118.         }catch (IOException e) {  
119.             e.printStackTrace();  
120.             throw e;  
121.         }finally{  
122.             try{  
123.                 fc.close();  
124.             }catch (IOException e) {  
125.                 e.printStackTrace();  
126.             }  
127.         }  
128.     }  
129. }