文件分割与合并（Java）

一、文件分割示意图

二、文件合并示意图

方式一：通过文件追加的方式

方式二：通过SequenceInputStream对其他输入流的逻辑串联。

测试RandomAccessFile随机访问文件

package FileSplitMerge;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

import IOOthers.FileUtil;

/**
 * RandomAccessFile
 * 此类的实例支持对随机访问文件的读取和写入。
 *
 * 文件分割的思路
 * 1、 分割的块数 size   n块
 * 2、 每一块的大小 blocksize
 *    最后一块:总的文件大小-(n-1)*blockSize
 */

public class Demo01 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile rnd = new RandomAccessFile(new File("G:/writer.txt"), "r");
        //UTF-8-->英文使用1个字节，中文使用3个字节来编码
        //GBK-->每个字符占用2个字节
        //从第12个读起       这是采用的是UTF-8
        rnd.seek(12);
        //定义缓冲大小
        byte[] flush = new byte[1024];
        //接收长度
        int len=0;

        while(-1!=(len=rnd.read(flush)))
        {
            if(len>=48)
            {
                System.out.println(new String(flush,0,48));
            }
            else {
                System.out.println(new String(flush,0,len));
            }
        }
        FileUtil.close(rnd);
    }
}

运行结果：

都有青春，
每个青春都有一个故事?
re ESX资源管理与性能优化
S1.1.11VMware
??FT-Practise
实验演示7：vApp-Practise
?

文件的分割与合并

package FileSplitMerge;

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.RandomAccessFile;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import IOOthers.FileUtil;

@SuppressWarnings("all")
public class SplitFile {

    //文件的路径
    private String filePath;
    //块数
    private int size;
    //每块的大小
    private long blocksize;
    //文件名
    private String fileName;
    //文件大小
    private long length;
    //分割后的存放目录
    private String destBlockPath;
    //每块的名称
    private List<String> blockPath;

    public SplitFile() {
        blockPath = new ArrayList<String>() ;
    }
    public SplitFile(String filePath,String destBlockPath) {
        this(filePath,1024, destBlockPath);
    }

    public SplitFile(String filePath, long blocksize,String destBlockPath) {
        this();
        this.filePath = filePath;
        this.destBlockPath = destBlockPath;
        this.blocksize = blocksize;
    }

    /**
     * 初始化操作 计算块数、确定文件名
     */
    public void init()
    {
        File src = null;
        //健壮性    创建成功就会得到构造方法初始化的值
        if(null==filePath || !(src=new File(filePath)).exists())
        {
            return;
        }
        if(src.isDirectory())
        {
            return;
        }

        //文件名    g:/writer.txt的 writer.txt
        this.fileName = src.getName();
        //文件的大小
        this.length = src.length();

        //修正    每块的大小
        if(this.blocksize>length) //如果每块的大小大于文本的长度，则每块的大小=长度
        {
            this.blocksize = length;
        }

        //确定块数        ceil最小(最接近负无穷大)浮点值，该值大于等于该参数，并等于某个整数。
        size = (int) Math.ceil(length*1.0/this.blocksize);

        //确定文件的路径
        initPathName();
    }

    private void initPathName()
    {
        for(int i=0;i<size;i++)
        {
            //List容器里面增加每一块的路径
            this.blockPath.add(destBlockPath+"/"+this.fileName+".part"+i);
        }
    }

    /**
     * 文件分割
     * 确定在第几块
     * 1、起始位置
     * 2、实际大小
     * @param destPath 分割文件存放目录
     * @throws IOException
     */
    public void split(String destPath) throws IOException
    {
        //确定文件的路径
        //每一块的名称
        //initPathName(destPath);
        long beginPos = 0;//起始点
        long actualBlockSize = blocksize;//实际大小
        //计算所有快的大小、位置、索引
        for(int i=0;i<size; i++)
        {
            if(i == size-1)
            {
                //最后一块
                actualBlockSize = this.length-beginPos;
            }
            //具体分割方法     第几块    起始分割地址        实际的块大小
            splitDetail(i,beginPos,actualBlockSize);
            beginPos += actualBlockSize;//本次的终点，下一次的起点
        }
    }

    /**
     * 文件分割  输入 输出
     * 文件拷贝
     * @param idx 第几块
     * @param beginPos 起始点
     * @param actualBlockSize 实际大小
     * @throws IOException
     */
    public void splitDetail(int idx,long beginPos,long actualBlockSize) throws IOException
    {
        //1、创建源
        File src = new File(this.filePath);//源文件
        //得到第几块的路径       List容器取出块路径
        File dest = new File(this.blockPath.get(idx));//目标文件

        //2、选择流
        RandomAccessFile raf = null;//输入流
        BufferedOutputStream bos = null;//输出流
        try
        {
             raf = new RandomAccessFile(src, "r");
             bos = new BufferedOutputStream(new FileOutputStream(dest));
             //3、读取文件
             raf.seek(beginPos);
             //4、缓冲区
             byte[] flush = new byte[1024];
             int len = 0;
             while(-1!=(len=raf.read(flush)))
             {
                 //写出
                 if(actualBlockSize-len>=0)//判断是否足够
                 {
                     bos.write(flush,0,len);//写出
                     actualBlockSize -= len;//剩余量
                 }
                 else
                 {
                     //读取每一块实际大小的最后一小部分   最后一次写出
                     bos.write(flush,0,(int)actualBlockSize);
                     break;//每个block最后一部分读取完之后，一定要break，否则就会继续读取
                 }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally{
            FileUtil.close(bos,raf);
        }
    }

    /**
     * 文件的合并   （方法一）
     */
    public void merge1(String destPath)
    {
        //创建源
        File dest = new File(destPath);
        //选择流
        BufferedOutputStream bos = null;//输出流
        BufferedInputStream bis = null;//输入流
        try {
            bos = new BufferedOutputStream(new FileOutputStream(dest,true));//表示追加

            for(int i=0; i<this.blockPath.size();i++)
            {
                //读取
                bis = new BufferedInputStream(new FileInputStream
                        (new File(this.blockPath.get(i))));
                //缓冲区
                byte[] flush = new byte[1024];
                //接收长度
                int len = 0;
                while(-1 !=(len = bis.read(flush)))
                {
                    //打印到控制台
                    //System.out.println(new String(flush,0,len));
                    bos.write(flush,0,len);
                }
                bos.flush();
                FileUtil.close(bis);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally
        {
            FileUtil.close(bos);
        }
    }

    /**
     * 文件的合并  （方法二）
     */
    public void merge(String destPath) throws IOException
    {
        //1、创建源
        File dest = new File(destPath);

        //2、选择流
        //SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，
        //并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，
        //直到到达包含的最后一个输入流的文件末尾为止。 

        SequenceInputStream sis = null;//输入流
        BufferedOutputStream bos = null;//输出源   

        //创建一个容器
        Vector<InputStream> vi = new Vector<InputStream>();
        for(int i=0; i<this.blockPath.size();i++)
        {
            vi.add(new BufferedInputStream(
                    new FileInputStream(new File(this.blockPath.get(i)))));
        }
        //SequenceInputStream sis = new SequenceInputStream(vi.elements());
        bos = new BufferedOutputStream(new FileOutputStream(dest,true));//表示追加
        sis = new SequenceInputStream(vi.elements());

        //缓冲区
        byte[] flush = new byte[1024];
        //接收长度
        int len = 0;
        while(-1 !=(len = sis.read(flush)))
        {
            //打印到控制台
            //System.out.println(new String(flush,0,len));
            bos.write(flush,0,len);
        }
        bos.flush();
        FileUtil.close(sis);
    }

    public static void main(String[] args) {
        //源文件路径、每块的大小(字节数)、目标快的路径
        SplitFile split = new SplitFile("g:/writer.txt",100,"g:/try");

        //文件初始化
        split.init();

        //文件分割
        try {
            //split.split("g:/try");
            split.split(split.destBlockPath);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //文件合并
        try {
            split.merge("g:/try/test.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //System.out.println(file.size);
    }
}