我们知道合并流SequenceInputStream可以将多个流合并到一起，RandomAccessFile可以设置指针指向要操作的数据位置，我的想法是，将一部电影切割若干碎片文件，分别用合并流和RandomAccessFile将这些碎片进行合并，其中RandomAccessFile使用多线程技术，每个线程负责一个碎片，多个线程同时写入一个文件中，比较合并流和RandomAccessFile两者的速度，于是有了如下代码：

1. package com.itheima;
   
2. /*
   
3. 需求：
   
4. 将一部视频切割成若干碎片文件，每个文件100M大小
   
5. 然后用两种方法将这些碎片文件重新合并
   
6. 第一种方法：合并流SequenceInputStream
   
7. 第二种方法：RandomAccessFile
   
8. 比较两种方法合并文件所用的时间
   
9. 
   
10. 结论：
    
11. 合并流：5913ms
    
12. Random：18174ms
    
13. */
    
14. import java.io.*;
    
15. import java.util.*;
    
16. public class CompMergeFiles{
    
17.         
    
18.         public static void main(String[] args) throws Exception{
    
19.                
    
20.                 //File file = new File("F:\\java\\碟中谍：幽灵协议.rmvb");
    
21.                 //int num = splitFile(file);
    
22. 
    
23.                 long start1 = System.currentTimeMillis();
    
24.                 mergeFiles_1(7);
    
25.                 long end1 = System.currentTimeMillis();
    
26.                 System.out.println("Sequence times:"+(end1-start1)+"ms");
    
27. 
    
28.                 long start2 = System.currentTimeMillis();
    
29.                 mergeFiles_2(7);
    
30.                 long end2 = System.currentTimeMillis();
    
31.                 System.out.println("Random times:"+(end2-start2)+"ms");
    
32.                
    
33.         }
    
34.         
    
35.         public static int splitFile(File file) throws IOException{
    
36.                
    
37.                 FileInputStream fis = new FileInputStream(file);
    
38.                 BufferedInputStream bufis = new BufferedInputStream(fis);//关联源文件
    
39. 
    
40.                 byte[] buf = new byte[1024*1024];
    
41.                 int len = 0,count = 0;
    
42.                 File partFile = new File("f:\\java\\"+(++count)+".part");//定义目标文件
    
43.                 while ((len=bufis.read(buf))!=-1){
    
44.                         if (partFile.length()>=1024*1024*100)//如果切割的碎片文件大于100M就新建一个文件
    
45.                                 partFile = new File("f:\\java\\"+(++count)+".part");
    
46. 
    
47.                         BufferedOutputStream bufos =
    
48.                                         new BufferedOutputStream(new FileOutputStream(partFile,true));
    
49.                         bufos.write(buf,0,len);
    
50.                         bufos.close();
    
51.                         
    
52.                 }
    
53.                 bufis.close();
    
54.                 return count;
    
55.         }
    
56. 
    
57.         //第一种合并文件的方法：SequenceInputStream
    
58.         public static void mergeFiles_1(int num) throws IOException{
    
59.                
    
60.                 ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();//集合用于存放读取流对象
    
61.                 for (int x=1;x<=num ;x++ ){
    
62.                         al.add(new FileInputStream("f:\\java\\"+x+".part"));
    
63.                 }
    
64. 
    
65.                 final Iterator<FileInputStream> it = al.iterator();
    
66.                 //匿名内部类，Enumeration接口对象，重写接口中的方法
    
67.                 Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
    
68.                         public boolean hasMoreElements(){
    
69.                                 return it.hasNext();
    
70.                         }
    
71.                         public FileInputStream nextElement(){
    
72.                                 return it.next();
    
73.                         }
    
74.                 };
    
75. 
    
76.                 SequenceInputStream sis = new SequenceInputStream(en);//建立合并流对象，将Enumeration对象传入
    
77.                 BufferedOutputStream bufos =
    
78.                                 new BufferedOutputStream(new FileOutputStream("f:\\java\\01.rmvb"));
    
79. 
    
80.                 byte[] buf = new byte[1024*1024];
    
81.                 int len = 0;
    
82.                 while ((len=sis.read(buf))!=-1){
    
83.                         bufos.write(buf,0,len);
    
84.                         bufos.flush();
    
85.                 }
    
86.                 sis.close();
    
87.                 bufos.close();
    
88.         }
    
89. 
    
90.         //第二种方法合并文件：RandomAccessFile
    
91.         public static void mergeFiles_2(int num) throws Exception{
    
92.                
    
93.                 RandomAccessFile raf = new RandomAccessFile("f:\\java\\02.rmvb","rw");//关联写入文件
    
94.                 Thread[] t = new Thread[num];//定义线程数组，大小为碎片数目
    
95.                 for (int x=1;x<=num ;x++ ){
    
96.                         t[x-1] = new Thread(new RandomMergeFile(x,raf));
    
97.                         t[x-1].start();//启动线程
    
98.                         t[x-1].join();//让主程序等待该线程结束
    
99.                 }
    
100.                 raf.close();//等到所有线程结束后关闭资源
     
101.         }
     
102. 
     
103. }
     
104. 
     
105. //定义一个类，用来封装向文件中写入数据的功能，该类实现了多线程
     
106. class RandomMergeFile implements Runnable{
     
107.         
     
108.         private int x = 0;//定义要读取的文件号码
     
109.         private RandomAccessFile raf = null;//用于接收RandomAccessFile的引用
     
110.         RandomMergeFile(int x,RandomAccessFile raf){
     
111.                 this.x = x;
     
112.                 this.raf = raf;
     
113.         }
     
114.         public void run(){
     
115.                 try{
     
116.                         BufferedInputStream bufis =
     
117.                                         new BufferedInputStream(new FileInputStream("f:\\java\\"+x+".part"));//读取碎片文件
     
118. 
     
119.                         byte[] buf = new byte[1024];
     
120.                         int len = 0;
     
121.                         raf.seek((x-1)*1024*1024*100L);//设置指针位置，按100M大小存储文件
     
122.                         while ((len=bufis.read(buf))!=-1){               
     
123.                                 raf.write(buf,0,len);
     
124.                         }
     
125.                         bufis.close();
     
126. 
     
127.                 }
     
128.                 catch (IOException e){
     
129.                         System.out.println(e);
     
130.                 }        
     
131.         }
     
132. }
     
133. 
     

复制代码

结果就是合并流要比RandomAccessFile要快，那么问题来了，多线程的操作应该要比单线程的合并流要快，为什么结果却是合并流速度快？不知道各位运行的情况如何。

我们知道合并流SequenceInputStream可以将多个流合并到一起，RandomAccessFile可以设置指针指向要操作的数据位置，我的想法是，将一部电影切割若干碎片文件，分别用合并流和RandomAccessFile将这些碎片进行合并，其中RandomAccessFile使用多线程技术，每个线程负责一个碎片，多个线程同时写入一个文件中，比较合并流和RandomAccessFile两者的速度，于是有了如下代码：

1. package com.itheima;
   
2. /*
   
3. 需求：
   
4. 将一部视频切割成若干碎片文件，每个文件100M大小
   
5. 然后用两种方法将这些碎片文件重新合并
   
6. 第一种方法：合并流SequenceInputStream
   
7. 第二种方法：RandomAccessFile
   
8. 比较两种方法合并文件所用的时间
   
9. 
   
10. 结论：
    
11. 合并流：5913ms
    
12. Random：18174ms
    
13. */
    
14. import java.io.*;
    
15. import java.util.*;
    
16. public class CompMergeFiles{
    
17.         
    
18.         public static void main(String[] args) throws Exception{
    
19.                
    
20.                 //File file = new File("F:\\java\\碟中谍：幽灵协议.rmvb");
    
21.                 //int num = splitFile(file);
    
22. 
    
23.                 long start1 = System.currentTimeMillis();
    
24.                 mergeFiles_1(7);
    
25.                 long end1 = System.currentTimeMillis();
    
26.                 System.out.println("Sequence times:"+(end1-start1)+"ms");
    
27. 
    
28.                 long start2 = System.currentTimeMillis();
    
29.                 mergeFiles_2(7);
    
30.                 long end2 = System.currentTimeMillis();
    
31.                 System.out.println("Random times:"+(end2-start2)+"ms");
    
32.                
    
33.         }
    
34.         
    
35.         public static int splitFile(File file) throws IOException{
    
36.                
    
37.                 FileInputStream fis = new FileInputStream(file);
    
38.                 BufferedInputStream bufis = new BufferedInputStream(fis);//关联源文件
    
39. 
    
40.                 byte[] buf = new byte[1024*1024];
    
41.                 int len = 0,count = 0;
    
42.                 File partFile = new File("f:\\java\\"+(++count)+".part");//定义目标文件
    
43.                 while ((len=bufis.read(buf))!=-1){
    
44.                         if (partFile.length()>=1024*1024*100)//如果切割的碎片文件大于100M就新建一个文件
    
45.                                 partFile = new File("f:\\java\\"+(++count)+".part");
    
46. 
    
47.                         BufferedOutputStream bufos =
    
48.                                         new BufferedOutputStream(new FileOutputStream(partFile,true));
    
49.                         bufos.write(buf,0,len);
    
50.                         bufos.close();
    
51.                         
    
52.                 }
    
53.                 bufis.close();
    
54.                 return count;
    
55.         }
    
56. 
    
57.         //第一种合并文件的方法：SequenceInputStream
    
58.         public static void mergeFiles_1(int num) throws IOException{
    
59.                
    
60.                 ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();//集合用于存放读取流对象
    
61.                 for (int x=1;x<=num ;x++ ){
    
62.                         al.add(new FileInputStream("f:\\java\\"+x+".part"));
    
63.                 }
    
64. 
    
65.                 final Iterator<FileInputStream> it = al.iterator();
    
66.                 //匿名内部类，Enumeration接口对象，重写接口中的方法
    
67.                 Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
    
68.                         public boolean hasMoreElements(){
    
69.                                 return it.hasNext();
    
70.                         }
    
71.                         public FileInputStream nextElement(){
    
72.                                 return it.next();
    
73.                         }
    
74.                 };
    
75. 
    
76.                 SequenceInputStream sis = new SequenceInputStream(en);//建立合并流对象，将Enumeration对象传入
    
77.                 BufferedOutputStream bufos =
    
78.                                 new BufferedOutputStream(new FileOutputStream("f:\\java\\01.rmvb"));
    
79. 
    
80.                 byte[] buf = new byte[1024*1024];
    
81.                 int len = 0;
    
82.                 while ((len=sis.read(buf))!=-1){
    
83.                         bufos.write(buf,0,len);
    
84.                         bufos.flush();
    
85.                 }
    
86.                 sis.close();
    
87.                 bufos.close();
    
88.         }
    
89. 
    
90.         //第二种方法合并文件：RandomAccessFile
    
91.         public static void mergeFiles_2(int num) throws Exception{
    
92.                
    
93.                 RandomAccessFile raf = new RandomAccessFile("f:\\java\\02.rmvb","rw");//关联写入文件
    
94.                 Thread[] t = new Thread[num];//定义线程数组，大小为碎片数目
    
95.                 for (int x=1;x<=num ;x++ ){
    
96.                         t[x-1] = new Thread(new RandomMergeFile(x,raf));
    
97.                         t[x-1].start();//启动线程
    
98.                         t[x-1].join();//让主程序等待该线程结束
    
99.                 }
    
100.                 raf.close();//等到所有线程结束后关闭资源
     
101.         }
     
102. 
     
103. }
     
104. 
     
105. //定义一个类，用来封装向文件中写入数据的功能，该类实现了多线程
     
106. class RandomMergeFile implements Runnable{
     
107.         
     
108.         private int x = 0;//定义要读取的文件号码
     
109.         private RandomAccessFile raf = null;//用于接收RandomAccessFile的引用
     
110.         RandomMergeFile(int x,RandomAccessFile raf){
     
111.                 this.x = x;
     
112.                 this.raf = raf;
     
113.         }
     
114.         public void run(){
     
115.                 try{
     
116.                         BufferedInputStream bufis =
     
117.                                         new BufferedInputStream(new FileInputStream("f:\\java\\"+x+".part"));//读取碎片文件
     
118. 
     
119.                         byte[] buf = new byte[1024];
     
120.                         int len = 0;
     
121.                         raf.seek((x-1)*1024*1024*100L);//设置指针位置，按100M大小存储文件
     
122.                         while ((len=bufis.read(buf))!=-1){               
     
123.                                 raf.write(buf,0,len);
     
124.                         }
     
125.                         bufis.close();
     
126. 
     
127.                 }
     
128.                 catch (IOException e){
     
129.                         System.out.println(e);
     
130.                 }        
     
131.         }
     
132. }
     
133. 
     

复制代码

结果就是合并流要比RandomAccessFile要快，那么问题来了，多线程的操作应该要比单线程的合并流要快，为什么结果却是合并流速度快？不知道各位运行的情况如何。