IO_File类使用：文件分割与合并

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class FileDivisionMargeDemo {

    public static void main(String[] args) {
        File file = new File("E:\\Java_IO\\第08章 文件与IO_14_文件分割示例.mp4");
        division(file,1024*1024*20); //以20M为单位分割成小文件
        
        
        try {
            InputStream in1 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\1_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            InputStream in2 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\2_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            InputStream in3 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\3_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            InputStream in4 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\4_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            InputStream in5 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\5_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            InputStream in6 = new FileInputStream(new File("E:\\Java_IO\\divisiono\\6_temp_第08章 文件与IO_14_文件分割示例.mp4"));
            
            //集合，可以看作是数组(里面可以存储任何的对象);内部实现使用了数组
            Vector<InputStream> v = new Vector<InputStream>();
            v.add(in1);
            v.add(in2);
            v.add(in3);
            v.add(in4);
            v.add(in5);
            v.add(in6);
            Enumeration<InputStream> es =v.elements();
            marge(es);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        
    }
    
    /**
     * 文件的分割
     */
    public static void division(File targetFile,long cutSize) {
        if(targetFile==null)return;         //判断目标文件为空就直接退出
        
        //定义切割后生成的小文件的个数
        int num = (int)(targetFile.length()%cutSize)==0?
                (int)(targetFile.length()/cutSize):(int)(targetFile.length()/cutSize)+1;
        
        try {
            //创建输入流，输入流是一次性执行的
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(targetFile));
            BufferedOutputStream out = null;   //输出流是一直都要执行的，所以放在循环里实现new
            byte[] bytes = null;               //定义每次读取时的字节数组，长度是随着定义的每次读取的长度而变
            int count = 0;                     //定义读取每个小文件的次数，即比如每个小文件是20M，byte的长度是1024字节，那么count就是读取多少个1024才能到20M
            int len = -1;                      //定义每次读取后存入byte字节数组的长度
            
            for(int i=0;i<num;i++) {           //循环小文件的个数，即循环体里面实现小文件的生成代码
                out = new BufferedOutputStream(new FileOutputStream("E:\\Java_IO\\divisiono\\"+(i+1)+"_temp_"+targetFile.getName()));
                if((int)cutSize<=1024) {
                    bytes = new byte[(int)cutSize];  //如果每个小文件的长度小于1024个字节，那么byte数组的长度就是cutSize
                    count = 1;                       //且每个小文件就只读去一次即可
                }else{
                    bytes = new byte[1024];          //如果每个小文件的长度大于1024个字节，那么byte数组的长度就定义为1024
                    count = (int)cutSize/1024;       //计算有多少个1024；注意：这里是整除，有可能是有余数的，余数的那次放在后面单独最后再读取一次
                }
                while(count>0 && ((len=in.read(bytes))!=-1)) {  //前面的if语句已经算出了count的值了
                    out.write(bytes,0,len);
                    count--;
                    out.flush();
                }
                
                if((cutSize%1024)!=0) {                  //接上面cutSize/1024 整除时有余数的情况，最后一次就单独在读取一次
                    bytes = new byte[(int)cutSize%1024]; //读取的byte数的长度就是余数的值
                    out.write(bytes,0,len);
                    out.flush();
                }
                out.close();
            }
            in.close();
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    
    
    
    /**
     * 文件的合并
     * SequenceInputStream表示其他输入流的逻辑级联。 它从一个有序的输入流集合开始，从第一个读取到文件的结尾，然后从第二个文件读取，依此类推，直到最后一个输入流达到文件的结尾。
     */
    public static void marge(Enumeration<InputStream> es) {

        SequenceInputStream sis = new SequenceInputStream(es);  //构造一个合并流
        try {
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream("E:\\Java_IO\\marge\\第08章 文件与IO_14_文件分割示例.mp4"));
            byte[] bytes = new byte[1024];
            int len = -1;
            while((len=sis.read(bytes))!=-1) {
                bos.write(bytes,0,len);
            }
            bos.close();
            sis.close();
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    

}