java语言实现文档的归档解归档

首先设计归档的协议

文件归档与解归档
运用IO流技术，把若干文件以流的方式写到一个文件里去，但是要区分文件和文件之间的边界，就需要设计每个文件的“头”。文件在磁盘上以字节数组的方式存在。“头”包含文件的扩展名类型（1个字节），文件的长度（4个字节），文件内容。解归档：先读文件类型，再读文件长度，接着读文件长度个字节。
增强版：文件名长度（1个字节长度），文件名字节数组（字符串解码getBytes），文件长度（4个字节），文件内容。

代码实现归档与解档：

//Archiver.java

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Archiver {
    public void newArchiverFile(String[] srcPaths, String yarPath) {
        FileOutputStream fout = null;
        try {
            //创建yar归档文件的输出流
            fout = new FileOutputStream(yarPath);
            for(String srcPath : srcPaths) {
                addFile(srcPath, fout);
                
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fout != null) {
                try {
                    fout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 向yar归档文件中添加文件
     * @param srcPath
     * @param fout
     */
    private void addFile(String srcPath, FileOutputStream fout) {
        FileInputStream fin = null;
        try {
            //1. 取出文件类型
            int fType = getFileType(srcPath);
            
            //2. 取出文件的长度
            fin = new FileInputStream(srcPath);
            int length = fin.available();
            
            //3. 将类型写入fout
            byte bFType = (byte) fType;
            fout.write(new byte[] {bFType});
            
            //4. 将长度写入yar中
            byte[] bytes = Int2ByteArr(length);
            fout.write(bytes);
            
            //5. 写入文件内容
            int len = -1;
            byte[] buffer = new byte[1024];
            while((len = fin.read(buffer)) != -1) {
                fout.write(buffer, 0, len);
            }
            
        } catch (Exception e) {
            
            e.printStackTrace();
        } finally {
            if (fin != null) {
                try {
                    fin.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }

    private byte[] Int2ByteArr(int i) {
        byte[] bytes = new byte[4];
        bytes[0] = (byte) i;
        bytes[1] = (byte) (i >> 8);
        bytes[2] = (byte) (i >> 16);
        bytes[3] = (byte) (i >> 24);
        return bytes;
    }

    /**
     * 得到文件类型
     * 0-txt
     * 1-jpg
     * 2-avi
     * 3-gif
     * 4-exe
     * 5-mp4
     * @param srcPath
     * @return
     */
    private int getFileType(String srcPath) {
        String ext = srcPath.substring(srcPath.lastIndexOf(".")).toLowerCase();
        int type = -1;
        if (".txt".equals(ext)) {
            type = 0;
        } else if (".jpg".equals(ext)) {
            type = 1;
        } else if (".avi".equals(ext)) {
            type = 2;
        } else if (".gif".equals(ext)) {
            type = 3;
        } else if (".exe".equals(ext)) {
            type = 4;
        } else if (".mp4".equals(ext)) {
            type = 5;
        } else {
            type = -1;
        }
        
        return type;
    }
    
    /**
     * 向原有yar中添加新文件
     */
    public void addFile(String srcPath, String yarPath) {
        try {
            FileOutputStream fos = new FileOutputStream(yarPath,true);//追加
            addFile(srcPath, fos);
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 解档文件
     */
    public void unarchive(String yarPath, String destDir) {
        try {
            FileInputStream fis = new FileInputStream(yarPath);
            int i = 1;
            //循环读取下一个文件
            while (readNextFile(destDir, (i++) + "", fis)) {
                
            }
            fis.close();    
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

    private boolean readNextFile(String destDir,String name, FileInputStream fis) {
        try {
            //文件类型
            int type = fis.read();
            //文件的扩展名
            String ext = getFileExt(type);
            if (type == -1) {
                return false;
            }
            
            //构造文件
            FileOutputStream fout = new FileOutputStream(destDir + "/" + name + ext);
            
            // 1.读取文件长度
            byte[] bytes = new byte[4];
            fis.read(bytes);
            
            // 2.转换字节数组为int
            int fileLength = byteArr2Int(bytes);
            
            // 3.读取文件
            byte[] buffer = new byte[1024];

            // 计算读取文件的循环次数
            int count = 0;
            if (fileLength / buffer.length == 0) {
                count = fileLength / buffer.length;
            }
            else {
                count = fileLength / buffer.length + 1;
            }
            //开始循环读取
            for (int i = 0; i < count; i++) {
                if (i != (count - 1)) {
                    fis.read(buffer);
                    fout.write(buffer);
                }
                else {
                    byte[] buf0 = new byte[fileLength - ((count - 1) * buffer.length)];
                    fis.read(buf0);
                    fout.write(buf0);
                }
            }
            fout.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return false;
    }

    private String getFileExt(int type) {
        String ext = ".tmp";
        switch (type) {
        case 0:
            ext = ".txt";
            break;
        case 1:
            ext = ".jpg";
            break;
        case 2:
            ext = ".avi";
            break;
        case 3:
            ext = ".gif";
            break;
        case 4:
            ext = ".exe";
            break;
        case 5:
            ext = ".mp4";
            break;
        default:
            ext = ".tmp";
            break;
        }
        return ext;
    }

    /**
     * 将长度为4的字节数组转换成int
     * @param bytes
     * @return
     */
    private int byteArr2Int(byte[] bytes) {
        //int i = (int)(bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]);
        int i0 = (bytes[3] & 0xff) << 24;
        int i1 = (bytes[2] & 0xff) << 16;
        int i2 = (bytes[1] & 0xff) << 8;
        int i3 = (bytes[0] & 0xff);
        return i0 | i1 | i2 | i3;
    }
}

测试代码:

//App.java

import org.junit.Test;

public class App {

    /**
     * 新建归档文件
     */
    @Test
    public void newArchiveFile() {
        Archiver archiver = new Archiver();
        String[] srcPaths = { "D:/arch/Sax.JPG", "D:/arch/1.mp4", "D:/arch/java笔记.txt"};
        String yarPath = "d:/arch/myYar.yar";
        archiver.newArchiverFile(srcPaths, yarPath);
        System.out.println("over");
    }
    
    /**
     * 向原有归档文件中添加新文件
     */
    @Test
    public void addFile(){
        Archiver archiver = new Archiver();
        archiver.addFile("D:/arch/hello.txt", "d:/arch/myYar.yar");
    }
    
    /**
     * 解档文件
     */
    @Test
    public void unarchiveFile() {
        Archiver archiver = new Archiver();
        archiver.unarchive("d:/arch/myYar.yar", "d:/arch/unarch");
    }

}

newArchiveFile()在D:arch目录下生成了myYar.yar归档文件大小为1.MP4 java笔记.txt Sax.jpg三个文件之和加15字节

unarchiveFile()之后在d:/arch/unarch下还原文件