IO流（SequenceInputStream序列流--文件拆分与合并）

　　一、文件拆分

　　1、将一个文件按照规定的大小进行分割成多个文件并将被分割详细信息保存至配置信息中

　　Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载，属性列表中每个键及其对应值都是一个字符串。

package ioDemo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * 文件切割
 *将一个文件按照规定的大小进行分割成多个文件并将被分割详细信息保存至配置信息中
 *
 * Created by lcj on 2017/11/14.
 */
public class partFileDemo {
    //定义全局变量 SIZE缓存大小
    private static final int SIZE = 1048576;

    public static void main(String[] args) throws IOException{
        //获取目标源文件
        File file = new File("D:\IMG_0859.JPG");
//        cutPartFile(file);
        cutPartFile02(file);
    }
    //重写分割文件方法
    public static void cutPartFile02(File file)throws IOException{
        //获取目标源文件
        FileInputStream fis = new FileInputStream(file);
        //定义一个1M缓冲区
        byte[] buf= new byte[SIZE];

        //创建目的地文件
        FileOutputStream fos = null;

        int len = 0 ;
        int count = 1 ;
        /**
         * 切割文件时，必须记住被切割文件的名称及切割出来的碎片文件的个数，以方便合并
         * 信息为了进行描述，使用键值对的文件，用到了properties对象
         * 信息是按照流对象存储在硬盘，故用properties对象
         * */
//        Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。
//        属性列表中每个键及其对应值都是一个字符串。
        Properties prop = new Properties();
        //存放分割文件路径
        File dir = new File("D:\partFiles");
        if (!dir.exists())
        {
            dir.mkdirs();//可创建多级目录
        }
        while ((len=fis.read(buf))!=-1)
        {
            fos = new FileOutputStream(new File(dir,(count++)+".part"));
            fos.write(buf,0,len);//每次写1M文件  写完即可以关闭改文件
            fos.close();
        }
        //将被分割文件信息保存到prop集合中
        prop.setProperty("partcount",count+"");
        prop.setProperty("filename",file.getName());
        //在file文件当前目录下   保存配置文件信息
        fos = new FileOutputStream(new File(dir,(count++) +".properties"));
        //将prop集合中的数据保存至文件中
        prop.store(fos,"save file info ");

        fos.close();
        fis.close();
}

    public static void cutPartFile(File file) throws IOException{

    //获取目标源文件
        FileInputStream fis = new FileInputStream(file);
        //定义一个1M缓冲区
        byte[] buf= new byte[SIZE];

        //创建目的地文件
        FileOutputStream fos = null;

        int len = 0 ;
        int count = 0 ;
        //存放分割文件路径
        File dir = new File("D:\partFiles");
        if (!dir.exists())
        {
            dir.mkdirs();//可创建多级目录
        }
        while ((len=fis.read(buf))!=-1)
        {
            fos = new FileOutputStream(new File(dir,(count++)+".part"));
            fos.write(buf,0,len);
        }
        fos.close();
        fis.close();
    }

}

 　　二、文件合并

　　getProperty:用指定的键在属性列表中搜索属性。如果在属性列表中未找到该键，则接着递归检查默认属性列表及其默认值。如果未找到属性，则此方法返回默认值变量

　  load:从输入流中读取属性列表（键和元素对）

      elements() 返回此向量的组件的枚举。

package ioDemo;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Properties;

/**
 * 合并文件
 * 将多个已经拆分的文件合并成一个文件中
 * Created by lcj on 2017/11/14.
 */
public class partFileDemo2 {
    public static void main(String[] args) throws IOException{
        //获取目标源文件
        File dir = new File("D:\partFiles");
//        megeFile(dir);
        megeFile2(dir);
    }

    public static void megeFile2(File dir) throws IOException{
        //获取指定目录下配合文件对象,通过过滤器
//        File[] files = dir.listFiles(new SuffixFilter(".properties"));
        File[] files = dir.listFiles(new SuffixFilter(".properties"));

        if (files.length !=1)
           throw  new RuntimeException(dir + "该目录下没有properties扩展名或者不唯一");

        //记录配置文件对象
        File confile = files[0];
        //获取该文件中的信息
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream(confile);
///load:从输入流中读取属性列表（键和元素对）
        prop.load(fis);
        //getProperty:用指定的键在属性列表中搜索属性。如果在属性列表中未找到该键，则接着递归检查默认属性列表及其默认值。如果未找到属性，则此方法返回默认值变量。
        String filename  = prop.getProperty("filename");
        int count = Integer.parseInt(prop.getProperty("partcount"));

        //获取该目录下的所有锁片文件
        File[] partFile = dir.listFiles(new SuffixFilter(".part"));

        if (partFile.length !=(count-1))
        {
            throw new RuntimeException("碎片文件不符合要求，个数不对！应该" + count+"个");
        }
        ///将碎片文件和流对象关联并存储到集合中
        ArrayList<FileInputStream> al  = new ArrayList<FileInputStream>();
        for (int x = 0 ; x<partFile.length;x++)
        {
            al.add(new FileInputStream(partFile[x]));
        }
        //将多个流合并成一个序列流
        //elements() 返回此向量的组件的枚举。
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        //序列流，字节读取流
        SequenceInputStream sis = new SequenceInputStream(en);
        //将合并文件放在File目下
        FileOutputStream fos = new FileOutputStream(new File(dir,filename));
        byte[] buf = new byte[1024];
        int len  = 0;
        while ((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }

    public static void megeFile(File dir) throws IOException{

        ArrayList<FileInputStream>  al = new ArrayList<FileInputStream>();
        for (int x=1;x<=3;x++)
        {
            al.add(new FileInputStream(new File(dir,x+".txt")));
        }
        //elements() 返回此向量的组件的枚举。
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        //序列流，字节读取流
        SequenceInputStream sis = new SequenceInputStream(en);
        //将合并文件放在File目下
        FileOutputStream fos = new FileOutputStream(new File(dir,"FileDemo.txt"));
        byte[] buf = new byte[1024];
        int len  = 0;
        while ((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
}

 　　SuffixFilter 类实现过滤文件

package ioDemo;

import java.io.File;
import java.io.FilenameFilter;

/**
 * Created by lcj on 2017/11/15.
 */
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);
    }
}

　　三、SequenceInputStream序列流实现多个文件合并成一个文件

　　Vector 类可以实现可增长的对象数组,

　　FileInputStream(输入流):输入流是用来读入数据的　　

　　OutputStream(输出流):输出流是用来写出数据的,
　　elements() 返回此向量的组件的枚举。

package ioDemo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/**
 * SequenceInputStream  序列流
 *将多个文件中数据合并到一个文件中
 * Created by lcj on 2017/11/13.
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException{
    /**
     * 将多个文件中数据合并到一个文件中
     * */
        //Vector 类可以实现可增长的对象数组,FileInputStream(输入流):输入流是用来读入数据的
        Vector<FileInputStream>  v = new Vector<FileInputStream>();
        v.add(new FileInputStream("D:\Project\IdeaProjects\test01_time\src\main\java\ioDemo\1.txt"));
        v.add(new FileInputStream("D:\Project\IdeaProjects\test01_time\src\main\java\ioDemo\2.txt"));
        v.add(new FileInputStream("D:\Project\IdeaProjects\test01_time\src\main\java\ioDemo\3.txt"));
        //elements() 返回此向量的组件的枚举。
        Enumeration<FileInputStream> en = v.elements();
        //序列流，字节读取流
        SequenceInputStream sis = new SequenceInputStream(en);
        //OutputStream(输出流):输出流是用来写出数据的,
        FileOutputStream fos = new FileOutputStream("D:\Project\IdeaProjects\test01_time\src\main\java\ioDemo\04.txt");
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
}