Android zip、tar+gz 压缩解压

package com.tool.util;

import androidx.annotation.Size;

import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
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.util.Arrays;
import java.util.Enumeration;
import java.util.zip.CRC32;
import java.util.zip.CheckedOutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 * 压缩工具类。
 * zip是将文件打包为zip格式的压缩文件。
 * gzip是将文件打包为tar.gz格式的压缩文件。
 * gzip只能对一个文件进行压缩，如果想压缩一大堆文件，就需要使用tar进行打包了。
 */
public class CompressUtil {

    private static final byte[] ZIP_HEADER_1 = new byte[]{0x1F, (byte) 0x8B, 0x03, 0x04};
    private static final byte[] ZIP_HEADER_2 = new byte[]{0x1F, (byte) 0x8B, 0x05, 0x06};
    private static final int BUFF_SIZE = 1024;

    /**
     * 判断文件是否压缩
     */
    public static boolean isCompressed(@Size(4) byte[] data) {
        if (data == null || data.length < ZIP_HEADER_1.length) return false;
        byte[] header = Arrays.copyOf(data, ZIP_HEADER_1.length);
        return Arrays.equals(header, ZIP_HEADER_1) || Arrays.equals(header, ZIP_HEADER_2);
    }

    public static byte[] zip(byte[] data) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ZipOutputStream zip = new ZipOutputStream(baos);
        byte[] result = null;
        try {
            String name = FileUtil.genNameByDate();
            zip.putNextEntry(new ZipEntry(name));
            zip.write(data);
            zip.closeEntry();
            zip.flush();
            result = baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                zip.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static byte[] unzip(byte[] data) {
        byte[] buffer = new byte[BUFF_SIZE];
        int len;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        ZipInputStream unzip = new ZipInputStream(bais);
        byte[] result = null;
        try {
            //这里的getNextEntry实际上是从byte数组里面读一段，如果没写这句，则后续解析失败
            ZipEntry zipEntry = unzip.getNextEntry();
            while ((len = unzip.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            result = baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                unzip.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static byte[] gzip(byte[] data) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gzip = null;
        byte[] result = null;
        try {
            gzip = new GZIPOutputStream(baos);
            gzip.write(data);
            gzip.flush();
            //gzip这里有点问题，必须close之后再取数据，否则有遗漏
            gzip.close();
            gzip = null;
            result = baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (gzip != null) gzip.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static byte[] ungzip(byte[] data) {
        byte[] buffer = new byte[BUFF_SIZE];
        int len;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        byte[] result = null;
        GZIPInputStream ungzip = null;
        try {
            ungzip = new GZIPInputStream(bais);
            while ((len = ungzip.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            result = baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ungzip != null) ungzip.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * ZIP压缩
     *
     * @param file    待压缩的文件或文件夹
     * @param zos     压缩流
     * @param baseDir 相对压缩文件的相对路径
     */
    private static void zip(File file, ZipOutputStream zos, String baseDir) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                zip(f, zos, baseDir + file.getName() + File.separator);
            }
        } else if (file.isFile()) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(file);
                ZipEntry zipEntry = new ZipEntry(baseDir + file.getName());
                zos.putNextEntry(zipEntry);
                int len;
                byte[] buffer = new byte[BUFF_SIZE];
                while ((len = fis.read(buffer)) != -1) {
                    zos.write(buffer, 0, len);
                }
                zos.closeEntry();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (fis != null) fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * Zip压缩
     *
     * @param srcFile 待压缩的文件或文件夹
     * @param dstDir  压缩至该目录，保持原文件名，后缀改为zip
     */
    public static void zip(File srcFile, String dstDir) {
        File file = new File(dstDir);
        //需要判断该文件存在，且是文件夹
        if (!file.exists() || !file.isDirectory()) file.mkdirs();

        String dstPath = dstDir + File.separator + srcFile.getName() + ".zip";
        FileOutputStream fos = null;
        CheckedOutputStream cos = null;
        ZipOutputStream zos = null;
        try {
            fos = new FileOutputStream(dstPath);
            cos = new CheckedOutputStream(fos, new CRC32());
            zos = new ZipOutputStream(cos);
            zip(srcFile, zos, "");
            zos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭数据流的时候要先关闭外层，否则会报Stream Closed的错误
                if (zos != null) zos.close();
                if (cos != null) cos.close();
                if (fos != null) fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 解压
     *
     * @param srcFile 待解压的文件
     * @param dstDir  解压到该目录，生成一个与原文件名相同的文件或文件夹
     */
    public static void unzip(File srcFile, String dstDir) {
        File file = new File(dstDir);
        //需要判断该文件存在，且是文件夹
        if (!file.exists() || !file.isDirectory()) file.mkdirs();
        ZipFile zipFile = null;
        FileOutputStream fos = null;
        InputStream is = null;
        try {
            //默认编码方式为UTF8
            zipFile = new ZipFile(srcFile);
            Enumeration<? extends ZipEntry> zipEntrys = zipFile.entries();
            byte[] buffer = new byte[BUFF_SIZE];
            int len = 0;
            while (zipEntrys.hasMoreElements()) {
                ZipEntry zipEntry = zipEntrys.nextElement();
                String fileName = dstDir + File.separator + zipEntry.getName();
                File tmpFile = new File(fileName);
                File parent = tmpFile.getParentFile();
                if (!parent.exists()) parent.mkdirs();
                if (zipEntry.isDirectory()) {
                    if (!tmpFile.exists()) tmpFile.mkdirs();
                } else {
                    fos = new FileOutputStream(tmpFile);
                    is = zipFile.getInputStream(zipEntry);
                    while ((len = is.read(buffer)) != -1) {
                        fos.write(buffer, 0, len);
                    }
                    is.close();
                    is = null;
                    fos.flush();
                    fos.close();
                    fos = null;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (zipFile != null) zipFile.close();
                if (is != null) is.close();
                if (fos != null) fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * tar打包，GZip压缩
     *
     * @param file    待压缩的文件或文件夹
     * @param taos    压缩流
     * @param baseDir 相对压缩文件的相对路径
     */
    private static void tarGZip(File file, TarArchiveOutputStream taos, String baseDir) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                tarGZip(f, taos, baseDir + file.getName() + File.separator);
            }
        } else {
            byte[] buffer = new byte[BUFF_SIZE];
            int len = 0;
            FileInputStream fis = null;
            TarArchiveEntry tarArchiveEntry = null;
            try {
                fis = new FileInputStream(file);
                tarArchiveEntry = new TarArchiveEntry(baseDir + file.getName());
                tarArchiveEntry.setSize(file.length());
                taos.putArchiveEntry(tarArchiveEntry);
                while ((len = fis.read(buffer)) != -1) {
                    taos.write(buffer, 0, len);
                }
                taos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (fis != null) fis.close();
                    if (tarArchiveEntry != null) taos.closeArchiveEntry();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * tar打包，GZip压缩
     *
     * @param srcFile 待压缩的文件或文件夹
     * @param dstDir  压缩至该目录，保持原文件名，后缀改为zip
     */
    public static void tarGZip(File srcFile, String dstDir) {
        File file = new File(dstDir);
        //需要判断该文件存在，且是文件夹
        if (!file.exists() || !file.isDirectory()) file.mkdirs();
        //先打包成tar格式
        String dstTarPath = dstDir + File.separator + srcFile.getName() + ".tar";
        String dstPath = dstTarPath + ".gz";

        FileOutputStream fos = null;
        TarArchiveOutputStream taos = null;
        try {
            fos = new FileOutputStream(dstTarPath);
            taos = new TarArchiveOutputStream(fos);
            tarGZip(srcFile, taos, "");
            taos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭数据流的时候要先关闭外层，否则会报Stream Closed的错误
                if (taos != null) taos.close();
                if (fos != null) fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        File tarFile = new File(dstTarPath);
        fos = null;
        GZIPOutputStream gzip = null;
        FileInputStream fis = null;
        try {
            //再压缩成gz格式
            fos = new FileOutputStream(dstPath);
            gzip = new GZIPOutputStream(fos);
            fis = new FileInputStream(tarFile);
            int len = 0;
            byte[] buffer = new byte[BUFF_SIZE];
            while ((len = fis.read(buffer)) != -1) {
                gzip.write(buffer, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) fis.close();
                //关闭数据流的时候要先关闭外层，否则会报Stream Closed的错误
                if (gzip != null) gzip.close();
                if (fos != null) fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //删除生成的tar临时文件
        if (tarFile.exists()) tarFile.delete();
    }

    /**
     * GZip解压，tar解包
     *
     * @param srcFile 待压缩的文件或文件夹
     * @param dstDir  压缩至该目录，保持原文件名，后缀改为zip
     */
    public static void untarGZip(File srcFile, String dstDir) {
        File file = new File(dstDir);
        //需要判断该文件存在，且是文件夹
        if (!file.exists() || !file.isDirectory()) file.mkdirs();
        byte[] buffer = new byte[BUFF_SIZE];
        FileInputStream fis = null;
        GzipCompressorInputStream gcis = null;
        TarArchiveInputStream tais = null;
        try {
            fis = new FileInputStream(srcFile);
            gcis = new GzipCompressorInputStream(fis);
            tais = new TarArchiveInputStream(gcis);
            TarArchiveEntry tarArchiveEntry;
            int len = 0;
            while ((tarArchiveEntry = tais.getNextTarEntry()) != null) {
                File f = new File(dstDir + File.separator + tarArchiveEntry.getName());
                if (tarArchiveEntry.isDirectory()) f.mkdirs();
                else {
                    File parent = f.getParentFile();
                    if (!parent.exists()) parent.mkdirs();
                    FileOutputStream fos = new FileOutputStream(f);
                    while ((len = tais.read(buffer)) != -1) {
                        fos.write(buffer, 0, len);
                    }
                    fos.flush();
                    fos.close();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fis != null) fis.close();
                //关闭数据流的时候要先关闭外层，否则会报Stream Closed的错误
                if(tais != null) tais.close();
                if(gcis != null) gcis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在module的build.gradle中添加如下依赖

dependencies {
	……
	//提供tar+gzip的打包方式(TarArchive和GZipCompress)
	//http://commons.apache.org/proper/commons-compress/download_compress.cgi
	implementation 'org.apache.commons:commons-compress:1.18'
}

JUnit 测试如下（注意：文件路径需要改成自己的）

	@Test
    public void compress() {
        assertTrue(ZipOutputStream.class == getDelater());

        byte[] data = randomBytes(65535);
        byte[] zipData = CompressUtil.zip(data);
        byte[] unzipData = CompressUtil.unzip(zipData);
        assertArrayEquals(data, unzipData);

        byte[] gzipData = CompressUtil.gzip(data);
        byte[] ungzipData = CompressUtil.ungzip(gzipData);
        assertArrayEquals(data, ungzipData);

        String dir = "D:\\test";
        String path = "D:\\test\\Test Folder";
        String target = "D:\\test\\A\\B";
        CompressUtil.zip(new File(path), dir);
        CompressUtil.unzip(new File(path + ".zip"), target);

        CompressUtil.tarGZip(new File(path), dir);
        CompressUtil.untarGZip(new File(path + ".tar.gz"), target);
    }