Day33

用随机流分割 进行封装

理解封装的思想

增加一些属性

构造器

初始化

分割思想不变

最后调用

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;

/**
 * 面向对象思想封装 分割
 */
public class SplitFile {
    //源头
    private File src;
    //目的地(文件夹)
    private String destDir;
    //所有分割后的文件存储路径
    private List<String>destPaths;
    //每块大小
    private int blockSize;
    //块数：多少块
    private  int size;

    public SplitFile(String srcPath,String destDir, int blockSize) {
        this.src = new File(srcPath);
        this.destDir = destDir;
        this.destPaths =new ArrayList<String>();
        this.blockSize = blockSize;
    //初始化
        init();
    }
    //初始化
    private void init(){
        //总长度
        long len =this.src.length();
        //块数：多少块
        this.size=(int)Math.ceil(len*1.0/blockSize);//向上取整，如果有小数点3.5，向上取整就是分四块
        //路径
        for (int i = 0; i <size ; i++) {
            this.destPaths.add((this.destDir+"/"+i+"-"+this.src.getName()));
        }
    }
    /**
     * 分割
     * 1、计算每块的起始位置及大小
     * 2、分割
     */
    public void split() throws IOException {
        //总长度
        long len =src.length();
        //起始位置和实际大小
        int beginPos=0;
        //实际大小
        int actuaSize=(int)(blockSize>len?len:blockSize);
        for (int i = 0; i <size ; i++) {
            beginPos=i*blockSize;
            if (i==size-1){//最后一块
                actuaSize=(int)len;
            }else {
                actuaSize=blockSize;
                len-=actuaSize;//剩余量
            }
            splitDetil(i,beginPos,actuaSize);
        }
    }
    /**
     * 指定第i起始位置和实际长度
     * @param i
     * @param beginPos
     * @param actuaSize
     * @throws IOException
     */
    private void splitDetil(int i, int beginPos, int actuaSize) throws IOException {
        RandomAccessFile raf = new RandomAccessFile(this.src, "r");
        RandomAccessFile raf2 = new RandomAccessFile(this.destPaths.get(i), "rw");
        //随机读取
        raf.seek(beginPos);
        //读取
        byte[] flush = new byte[1024];//缓冲容器
        int len = -1;//接受长度
        while ((len = raf.read(flush)) != -1) {
            if (actuaSize>len){//获取本次读取的所有内容
                raf2.write(flush,0,len);
                actuaSize-=len;
            }else {
                raf2.write(flush,0, actuaSize);
                break;
            }
        }
        raf.close();
        raf2.close();
    }

    public static void main(String[] args) throws IOException {
        SplitFile sf=new SplitFile("src/com/sxt/io/SplitFile.java","dest", 1024);
        sf.split();
    }
}

合并流

SequenceInputStream

多个输入流读取到一个合并流SequenceInputStream中给程序

SequenceInputStream中有个Enumeration接口

看到这个Enumeration接口我们就会用这个Vector，Vector有个elements方法会返回Enumeration

package com.sxt.io;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * 面向对象思想封装 分割
 */
public class SplitFile {
    //源头
    private File src;
    //目的地(文件夹)
    private String destDir;
    //所有分割后的文件存储路径
    private List<String>destPaths;
    //每块大小
    private int blockSize;
    //块数：多少块
    private  int size;

    public SplitFile(String srcPath,String destDir, int blockSize) {
        this.src = new File(srcPath);
        this.destDir = destDir;
        this.destPaths =new ArrayList<String>();
        this.blockSize = blockSize;
    //初始化
        init();
    }
    //初始化
    private void init(){
        //总长度
        long len =this.src.length();
        //块数：多少块
        this.size=(int)Math.ceil(len*1.0/blockSize);//向上取整，如果有小数点3.5，向上取整就是分四块
        //路径
        for (int i = 0; i <size ; i++) {
            this.destPaths.add((this.destDir+"/"+i+"-"+this.src.getName()));
        }
    }
    /**
     * 分割
     * 1、计算每块的起始位置及大小
     * 2、分割
     */
    public void split() throws IOException {
        //总长度
        long len =src.length();
        //起始位置和实际大小
        int beginPos=0;
        //实际大小
        int actuaSize=(int)(blockSize>len?len:blockSize);
        for (int i = 0; i <size ; i++) {
            beginPos=i*blockSize;
            if (i==size-1){//最后一块
                actuaSize=(int)len;
            }else {
                actuaSize=blockSize;
                len-=actuaSize;//剩余量
            }
            splitDetil(i,beginPos,actuaSize);
        }
    }
    /**
     * 指定第i起始位置和实际长度
     * @param i
     * @param beginPos
     * @param actuaSize
     * @throws IOException
     */
    private void splitDetil(int i, int beginPos, int actuaSize) throws IOException {
        RandomAccessFile raf = new RandomAccessFile(this.src, "r");
        RandomAccessFile raf2 = new RandomAccessFile(this.destPaths.get(i), "rw");
        //随机读取
        raf.seek(beginPos);
        //读取
        byte[] flush = new byte[1024];//缓冲容器
        int len = -1;//接受长度
        while ((len = raf.read(flush)) != -1) {
            if (actuaSize>len){//获取本次读取的所有内容
                raf2.write(flush,0,len);
                actuaSize-=len;
            }else {
                raf2.write(flush,0, actuaSize);
                break;
            }
        }
        raf.close();
        raf2.close();
    }

    /**
     * 文件的合并 合并流
     */
    public void merge(String destPath) throws IOException {
        //输出流
        OutputStream os = new BufferedOutputStream(new FileOutputStream(destPath,true));
        Vector<InputStream> vi=new Vector<InputStream>();
        SequenceInputStream sis=null;
        //输入流
        for (int i = 0; i <destPaths.size() ; i++) {
            vi.add(new BufferedInputStream(new FileInputStream(destPaths.get(i))));
            }
        sis=new SequenceInputStream(vi.elements());
        //拷贝
        byte[] flush = new byte[1024];//缓冲容器
        int len = -1;//接受长度
        while ((len = sis.read(flush)) != -1) {
            //分段写出
            os.write(flush, 0, len);

        }
        os.flush();
        sis.close();
        os.close();
    }

    public static void main(String[] args) throws IOException {
        SplitFile sf=new SplitFile("src/com/sxt/io/SplitFile.java","dest", 1024);
        sf.split();
        sf.merge("aaa.java");
    }
}