文件切割与合并

Posted 2020-08-12

  1 /*
  2  * 文件切割器。
  3  * 
  4  * 
  5  * 
  6  * 
  7  */
  8 
  9 public class SplitFileDemo {
 10 
 11     private static final int SIZE = 1024 * 1024;
 12 
 13     /**
 14      * @param args
 15      * @throws Exception
 16      */
 17     public static void main(String[] args) throws Exception {
 18 
 19         File file = new File("c:\\aa.mp3");
 20 
 21         splitFile_2(file);
 22     }
 23 
 24     private static void splitFile_2(File file) throws IOException {
 25 
 26         // 用读取流关联源文件。
 27         FileInputStream fis = new FileInputStream(file);
 28 
 29         // 定义一个1M的缓冲区。
 30         byte[] buf = new byte[SIZE];
 31 
 32         // 创建目的。
 33         FileOutputStream fos = null;
 34 
 35         int len = 0;
 36         int count = 1;
 37         
 38         
 39         /*
 40          * 切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数。 以方便于合并。
 41          * 这个信息为了进行描述，使用键值对的方式。用到了properties对象
 42          * 
 43          */
 44         Properties prop  = new Properties();
 45         
 46     
 47 
 48         File dir = new File("c:\\partfiles");
 49         if (!dir.exists())
 50             dir.mkdirs();
 51 
 52         while ((len = fis.read(buf)) != -1) {
 53 
 54             fos = new FileOutputStream(new File(dir, (count++) + ".part"));
 55             fos.write(buf, 0, len);
 56             fos.close();
 57         }
 58         
 59         //将被切割文件的信息保存到prop集合中。
 60         prop.setProperty("partcount", count+"");
 61         prop.setProperty("filename", file.getName());
 62         
 63         
 64         
 65         fos = new FileOutputStream(new File(dir,count+".properties"));
 66         
 67         //将prop集合中的数据存储到文件中。 
 68         prop.store(fos, "save file info");
 69 
 70         fos.close();
 71         fis.close();
 72 
 73     }
 74 
 75     public static void splitFile(File file) throws IOException {
 76 
 77         // 用读取流关联源文件。
 78         FileInputStream fis = new FileInputStream(file);
 79 
 80         // 定义一个1M的缓冲区。
 81         byte[] buf = new byte[SIZE];
 82 
 83         // 创建目的。
 84         FileOutputStream fos = null;
 85 
 86         int len = 0;
 87         int count = 1;
 88 
 89         File dir = new File("c:\\partfiles");
 90         if (!dir.exists())
 91             dir.mkdirs();
 92 
 93         while ((len = fis.read(buf)) != -1) {
 94 
 95             fos = new FileOutputStream(new File(dir, (count++) + ".part"));
 96             fos.write(buf, 0, len);
 97         }
 98 
 99         fos.close();
100         fis.close();
101 
102     }
103 
104 }

 

 

文件合并：

 

  1 public class MergeFile {
  2 
  3     /**
  4      * @param args
  5      * @throws IOException 
  6      */
  7     public static void main(String[] args) throws IOException {
  8 
  9         File dir = new File("c:\\partfiles");
 10         
 11         mergeFile_2(dir);
 12     }
 13     
 14     public static void mergeFile_2(File dir) throws IOException {
 15         
 16         /*
 17          * 获取指定目录下的配置文件对象。
 18          */
 19         File[] files = dir.listFiles(new SuffixFilter(".properties"));
 20         
 21         if(files.length!=1)
 22             throw new RuntimeException(dir+",该目录下没有properties扩展名的文件或者不唯一");
 23         //记录配置文件对象。
 24         File confile = files[0];
 25         
 26         
 27         
 28         //获取该文件中的信息================================================。
 29         
 30         Properties prop = new Properties();
 31         FileInputStream fis = new FileInputStream(confile);
 32         
 33         prop.load(fis);
 34         
 35         String filename = prop.getProperty("filename");        
 36         int count = Integer.parseInt(prop.getProperty("partcount"));
 37         
 38         
 39         
 40         
 41         //获取该目录下的所有碎片文件。 ==============================================
 42         File[] partFiles = dir.listFiles(new SuffixFilter(".part"));
 43         
 44         if(partFiles.length!=(count-1)){
 45             throw new RuntimeException(" 碎片文件不符合要求，个数不对!应该"+count+"个");
 46         }
 47         
 48         
 49         
 50         //将碎片文件和流对象关联 并存储到集合中。 
 51         ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
 52         for(int x=0; x<partFiles.length; x++){
 53             
 54             al.add(new FileInputStream(partFiles[x]));
 55         }
 56         
 57         
 58         
 59         //将多个流合并成一个序列流。 
 60         Enumeration<FileInputStream> en = Collections.enumeration(al);
 61         SequenceInputStream sis = new SequenceInputStream(en);
 62         
 63         FileOutputStream fos = new FileOutputStream(new File(dir,filename));
 64         
 65         byte[] buf = new byte[1024];
 66         
 67         int len = 0;
 68         while((len=sis.read(buf))!=-1){
 69             fos.write(buf,0,len);
 70         }
 71         
 72         fos.close();
 73         sis.close();
 74         
 75         
 76         
 77         
 78         
 79         
 80     }
 81 
 82     public static void mergeFile(File dir) throws IOException{
 83         
 84         
 85         ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
 86         
 87         for(int x=1; x<=3 ;x++){
 88             al.add(new FileInputStream(new File(dir,x+".part")));
 89         }
 90         
 91         Enumeration<FileInputStream> en = Collections.enumeration(al);
 92         SequenceInputStream sis = new SequenceInputStream(en);
 93         
 94         FileOutputStream fos = new FileOutputStream(new File(dir,"1.bmp"));
 95         
 96         byte[] buf = new byte[1024];
 97         
 98         int len = 0;
 99         while((len=sis.read(buf))!=-1){
100             fos.write(buf,0,len);
101         }
102         
103         fos.close();
104         sis.close();
105         
106     }
107 
108 }

 

 

public class SuffixFilter implements FilenameFilter {

    private String suffix;
    
    public SuffixFilter(String suffix) {
        super();
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File dir, String name) {

        return name.endsWith(suffix);
    }

}