先上代码:

1. /*
   
2. 需求:
   
3. 1.把电影文件按照10M每单位的大小分隔.
   
4. 2.然后把电影合并,保证其可以正常观看.
   
5. 
   
6. */
   
7. import java.io.*;
   
8. import java.util.*;
   
9. class FilmSplit
   
10. {
    
11.         public static void filmSplit() throws IOException  //切割
    
12.         {
    
13.                 //new 字节输入流
    
14.                 FileInputStream fis = new FileInputStream("F:\\1.MP4");
    
15.                 //new 字节输出流
    
16.                 FileOutputStream fos = null;
    
17.                 //定义缓冲
    
18.                 byte[] buf = new byte[1024*1024];
    
19.                 //定义计数器
    
20.                 int len = 0, time = 0, sum = 0;
    
21.                 //此处while循环如何优化?
    
22.                 while (sum < 4)  //限定次数,不产生多余空白文件
    
23.                 {
    
24.                         fos = new FileOutputStream("F:\\split\\"+ (sum++) + ".part");  //先产生目的流
    
25.                         while ((time < 10) && ((len = fis.read(buf)) != -1))                //再存入数据. 限定10M
    
26.                         {
    
27.                                 time++;
    
28.                                 fos.write(buf, 0, len);
    
29.                         }
    
30.                         fos.close();
    
31.                         time = 0;
    
32.                 }
    
33.                 fis.close();
    
34.         }
    
35.         public static void merge() throws IOException  //合并
    
36.         {
    
37.                 //new vector集合
    
38.                 Vector<FileInputStream> v = new Vector<>();
    
39.                 //循环添加源
    
40.                 for(int x = 0; x < 4; x++)
    
41.                 {
    
42.                         v.add(new FileInputStream("F:\\split\\"+ x + ".part"));
    
43.                 }
    
44.                 //获取Enumeration枚举
    
45.                 Enumeration<FileInputStream> en = v.elements();
    
46.                 //合并流
    
47.                 SequenceInputStream sis = new SequenceInputStream(en);
    
48.                 //输出流
    
49.                 FileOutputStream fos = new FileOutputStream("F:\\split\\kongfu.rmvb");
    
50.                 byte[] buf = new byte[1024];
    
51.                 int len = 0;
    
52.                 while((len = sis.read(buf)) != -1)
    
53.                 {
    
54.                         fos.write(buf, 0, len);
    
55.                 }
    
56.                 fos.close();
    
57.                 sis.close();
    
58.         }
    
59.         public static void main(String[] args) throws IOException
    
60.         {
    
61.                 //filmSplit(); //切割
    
62.                  merge();                //合并
    
63.         }
    
64. }
    

复制代码

自己写了个小程序,按照毕老师的思路,但是现在遇到个小问题.
文件按体积大小切割没有问题了,但是,无法自动的控制切割的次数.
总是,切割次数要手动按照源文件大小来设定,如果设定的多了,就会产生很多空白文件.
如果,外循环通过 (len = sis.read(buf)) != -1   来判断的话,
那么内部循环的数据一直在存储同一次的数据.
就是把第一次数组内的数据存储10次后,才读取第二次.  囧~!
有何方法可以控制外循环?  来保证资源的合理利用还有次数控制呢?

-----------------------------
想到一方法:
先获取媒体源的字节数,然后再除以要切割的体积.
值为int,所以再加1.  这样就刚好可以装下媒体数据,而不会产生多余文件.
但是这样感觉好麻烦...  

参考该帖子http://bbs.itheima.com/forum.php ... id=36506&highlight=一个IO流程序的问题
另外媒体切割，好像还涉及个位操作，记不太清了

朱玉玺 发表于 2013-2-3 13:38
参考该帖子http://bbs.itheima.com/forum.php ... id=36506&highlight=一个IO流程序的问题
另外媒体切割， ...

不是相同的问题  ..

媒体切割和文件切割都一样,只是对于单位容量大小的控制不同.

修改完毕，请楼主自测....

1. /*
   
2. 需求:
   
3. 1.把电影文件按照10M每单位的大小分隔.
   
4. 2.然后把电影合并,保证其可以正常观看.
   
5. 
   
6. */
   
7. import java.io.*;
   
8. import java.util.*;
   
9. class FilmSplit
   
10. {
    
11.             static int sum;
    
12. static int count;
    
13.         public static void filmSplit() throws IOException  //切割
    
14.         {
    
15.                 //new 字节输入流
    
16.                     File file=new File("F:"+File.separator+"1.MP4");
    
17.                 FileInputStream fis = new FileInputStream(file);
    
18.                 //new 字节输出流
    
19.                 FileOutputStream fos = null;
    
20.                 //定义缓冲
    
21.                 byte[] buf = new byte[1024*1024*count];
    
22.                 //定义计数器
    
23.                 int len = 0;
    
24.                 //此处while循环如何优化?
    
25.             
    
26.                          //先产生目的流
    
27.                         while (((len = fis.read(buf)) != -1))                //再存入数据. 限定10M
    
28.                         {
    
29.                                 fos = new FileOutputStream("F:"+File.separator+"split"+File.separator+ (sum++) + ".part");
    
30.                                 fos.write(buf, 0, len);
    
31.                                 fos.close();
    
32.                         }
    
33.                      fis.close();
    
34.         }
    
35.         public static void merge() throws IOException  //合并
    
36.         {
    
37.                 //new vector集合
    
38.                 Vector<FileInputStream> v = new Vector<>();
    
39.                 //循环添加源
    
40.                 for(int x = 0; x < sum; x++)
    
41.                 {
    
42.                         v.add(new FileInputStream("F:"+File.separator+"split"+File.separator+ x + ".part"));
    
43.                 }
    
44.                 //获取Enumeration枚举
    
45.                 Enumeration<FileInputStream> en = v.elements();
    
46.                 //合并流
    
47.                 SequenceInputStream sis = new SequenceInputStream(en);
    
48.                 //输出流
    
49.                 FileOutputStream fos = new FileOutputStream("F:"+File.separator+"split"+File.separator+"kongfu.rmvb");
    
50.                 byte[] buf = new byte[1024];
    
51.                 int len = 0;
    
52.                 while((len = sis.read(buf)) != -1)
    
53.                 {
    
54.                         fos.write(buf, 0, len);
    
55.                 }
    
56.                 fos.close();
    
57.                 sis.close();
    
58.         }
    
59.         public static void main(String[] args) throws IOException
    
60.         {
    
61.                 filmSplit(); //切割
    
62.                  merge();                //合并
    
63.         }
    
64. }

复制代码

逻辑混乱，直接去掉外外循环，用外部变量控制每次切割生成单个文件的数据容量.....

赵文 发表于 2013-2-3 20:34
修改完毕，请楼主自测....逻辑混乱，直接去掉外外循环，用外部变量控制每次切割生成单个文件的数据容量.... ...

呵呵..

如果我需要1GB 为单位的话,是不是要我的内存爆掉??  
不过还是多谢了.  我之前找到方法了.. 但是感觉不是很简洁..
我可以控制  while ((time < 10) && ((len = fis.read(buf)) != -1))   中time的次数来保证单位大小. 这样不涉及内存的溢出问题.
另外  int num = 1024*1024*10;  中的10 可以和time条件是一个参数,这样感觉更好点.

1. public static void filmSplit() throws IOException  //切割
   
2.         {
   
3.                 //new 字节输入流
   
4.                 FileInputStream fis = new FileInputStream("F:\\split\\1.MP4");
   
5.                 //new 字节输出流
   
6.                 FileOutputStream fos = null;
   
7.                 //定义计数器
   
8.                 int len = 0, time = 0, sum = 0;
   
9.                 //定义缓冲
   
10.                 int num = 1024*1024*10;
    
11.                 byte[] buf = new byte[num/10];
    
12.                
    
13.                 int se = fis.available()/num + 1;
    
14.                 System.out.println(se);
    
15.                 for (int i = 0; i < se; i++)  //限定次数,不产生多余空白文件
    
16.                 {
    
17.                         fos = new FileOutputStream("F:\\split\\"+ (sum++) + ".part");  //先产生目的流
    
18.                         while ((time < 10) && ((len = fis.read(buf)) != -1))                // 再存入数据. 限定10M
    
19.                         {
    
20.                                 time++;
    
21.                                 fos.write(buf, 0, len);
    
22.                         }
    
23.                         fos.close();
    
24.                         time = 0;
    
25.                 }
    
26.                 fis.close();
    
27.         }
    

复制代码

司懿卓 发表于 2013-2-3 21:08
呵呵..

如果我需要1GB 为单位的话,是不是要我的内存爆掉??  

把你找到得方法贴上来，大家共勉....

赵文 发表于 2013-2-3 21:13
把你找到得方法贴上来，大家共勉....

恩 ,已经贴上来了..  帮忙看看有什么不到之处..
谢谢啦.


几处需要修改:
1. 把int num = 1024*1024*10; 中的10 和 time的控制 声明成 一个参数.
2. fos.write(buf, 0, len); 语句后添加flush方法,这样更能避免内存溢出问题.