下面是自己写的代码

1. package IO;
   
2. 
   
3. import java.io.File;
   
4. import java.io.FileInputStream;
   
5. import java.io.FileOutputStream;
   
6. import java.io.IOException;
   
7. import java.io.SequenceInputStream;
   
8. import java.util.ArrayList;
   
9. import java.util.Enumeration;
   
10. import java.util.Iterator;
    
11. import java.util.List;
    
12. 
    
13. /**
    
14. * 合并分割文件
    
15. *                
    
16. *                
    
17. *
    
18. *
    
19. * @author Administrator
    
20. *
    
21. */
    
22. public class SplitFile {
    
23.         public static void main(String[] args) throws IOException{
    
24.                 //要分割的文件
    
25.                 File file=new File("1.jpg");
    
26.                 int jpg=5;
    
27.                 split(file, jpg);
    
28.                 merge("合并后的图片.jpg","1.part","2.part","3.part","4.part","5.part");
    
29.         }
    
30.         //分割文件，file要分割的文件，jpg分割成多少份
    
31.         public static void split(File file,int part) throws IOException{
    
32.                
    
33.                 //自定义分割成多少个文件后，每个分割文件的最大值
    
34.                 int partSize=(int)file.length()/part+1;
    
35.                 //用来接受从文件读取的字节
    
36.                 byte[] buf=new byte[1024];
    
37.                 //从文件读取了多少个字节
    
38.                 int len=0;
    
39.                 //当前分割文件的大小
    
40.                 int size=0;
    
41.                 //每次动态创建文件的名字
    
42.                 int i=1;
    
43.                 //输入流，读取要分割文件的字节
    
44.                 FileInputStream fis=new FileInputStream(file);
    
45.                 //输出流，写到分割文件的输出流
    
46.                 FileOutputStream fos=new FileOutputStream(i+".part");
    
47.                 //读取源文件
    
48.                 while((len=fis.read(buf))!=-1){
    
49.                         //写入buf字节数组后，分割文件的大小
    
50.                         size+=len;
    
51.                         //如果分割文件的最大值 > 即将写入buf后分割文件的实际大小
    
52.                         if(size<=partSize){
    
53.                                 //将buf写入到分割文件中
    
54.                                 fos.write(buf);
    
55.                         }
    
56.                         //否则
    
57.                         else{
    
58.                                 //把分割文件写满，从buf的第一个元素开始，写len-(size-partSize)个元素
    
59.                                 fos.write(buf, 0, len-(size-partSize));
    
60.                                 //关闭输出流
    
61.                                 fos.close();
    
62.                                 //创建新输出流，
    
63.                                 fos=new FileOutputStream(++i+".part");
    
64.                                 //把buf中未被写入的部分，写入到新建的分割文件中
    
65.                                 fos.write(buf, len-(size-partSize), size-partSize);
    
66.                                 //将size设置成已写入分割文件的字节数
    
67.                                 size=size-partSize;
    
68.                         }
    
69.                         //当前buf已经全部写出去了，读取下一个buf
    
70.                 }
    
71.                 //源文件全部读取完毕，不需要读取了，关闭输入流
    
72.                 fis.close();
    
73.                 //关闭最后一个创建的输出流
    
74.                 fos.close();
    
75.         }
    
76.         //合并分割文件,desPath合并后的文件，filePath需要合并的文件
    
77.         public static void merge(String desPath,String... filePaths) throws IOException{
    
78.                 //得到参数中的文件输入流，放到集合中
    
79.                 List<FileInputStream> files=new ArrayList<FileInputStream>();
    
80.                 for(int i=0;i<filePaths.length;i++){
    
81.                         File file=new File(filePaths[i]);
    
82.                         System.out.println(file.getAbsolutePath());
    
83.                         files.add(new FileInputStream(file));
    
84.                 }
    
85.                
    
86.                 //使用集合的迭代器
    
87.                 final Iterator<FileInputStream> it=files.iterator();
    
88.                 //用内部类实现Enumeration接口，创建enume对象
    
89.                 Enumeration<FileInputStream> enume=new Enumeration<FileInputStream>() {
    
90.                        
    
91.                         @Override
    
92.                         public FileInputStream nextElement() {
    
93.                                 // TODO Auto-generated method stub
    
94.                                 return it.next();
    
95.                         }
    
96.                        
    
97.                         @Override
    
98.                         public boolean hasMoreElements() {
    
99.                                 // TODO Auto-generated method stub
    
100.                                 return it.hasNext();
     
101.                         }
     
102.                 };
     
103.                 //使用SequenceInputStream合并输入流,合并分割文件
     
104.                 SequenceInputStream sequence=new SequenceInputStream(enume);
     
105.                 FileOutputStream fos=new FileOutputStream(desPath);
     
106.                 byte[] buf=new byte[1024];
     
107.                 int len=0;
     
108.                 while((len=sequence.read(buf))!=-1){
     
109.                         fos.write(buf, 0, len);
     
110.                 }
     
111.                 fos.close();
     
112.                 sequence.close();
     
113.         }
     
114. }
     

复制代码

你贴上来的目的是什么？

这些代码相信看过视频的都有敲过，不知道哥们贴上来是出于什么目的呢？

格子、 发表于 2014-8-27 07:44
这些代码相信看过视频的都有敲过，不知道哥们贴上来是出于什么目的呢？

那你觉得我这个跟视频是一样的吗，你仔细看过吗，我觉得这个流程比较有难度，重点不是用了什么知识，是这个思路，好吗
这是我自己的想法，我看视频也觉得挺简单，但是自己敲的时候，有很多细节要注意
不信你自己去敲一遍

给定一个指定文件，可以自己随便定义分割几个个数

优乐 发表于 2014-8-27 08:30
那你觉得我这个跟视频是一样的吗，你仔细看过吗，我觉得这个流程比较有难度，重点不是用了什么知识，是这 ...

我想你理解错我意思了，我意思是请说明一个你和大家要交流的是什么！！！直接这么贴上了，也没什么说明，你觉得你看了会是什么感受？？？

帖子有点长，楼主要是前面或后面有点总结的话，就更好了

嗯嗯，能带上总结就好了，比如和视频讲的区别