利用Java實現壓縮與解壓縮（zip、gzip）支持中文路徑

zip扮演着歸檔和壓縮兩個角色；gzip並不將文件歸檔，僅只是對單個文件進行壓縮，所以，在UNIX平臺上，命令tar通常用來創建一個檔案文件，然後命令gzip來將檔案文件壓縮。

Java I/O類庫還收錄了一些能讀寫壓縮格式流的類。要想提供壓縮功能，只要把它們包在已有的I/O類的外面就行了。這些類不是Reader和Writer，而是InputStream和OutStreamput的子類。這是因爲壓縮算法是針對byte而不是字符的。

相關類與接口：
Checksum 接口：被類Adler32和CRC32實現的接口
Adler32 ：使用Alder32算法來計算Checksum數目
CRC32 ：使用CRC32算法來計算Checksum數目

CheckedInputStream ：InputStream派生類，可得到輸入流的校驗和Checksum，用於校驗數據的完整性
CheckedOutputStream ：OutputStream派生類，可得到輸出流的校驗和Checksum， 用於校驗數據的完整性

DeflaterOutputStream ：壓縮類的基類。
ZipOutputStream ：DeflaterOutputStream的一個子類，把數據壓縮成Zip文件格式。
GZIPOutputStream ：DeflaterOutputStream的一個子類，把數據壓縮成GZip文件格式

InflaterInputStream ：解壓縮類的基類
ZipInputStream ：InflaterInputStream的一個子類，能解壓縮Zip格式的數據
GZIPInputStream ：InflaterInputStream的一個子類，能解壓縮Zip格式的數據

ZipEntry 類：表示 ZIP 文件條目
ZipFile 類：此類用於從 ZIP 文件讀取條目

用GZIP進行對單個文件壓縮

GZIP的接口比較簡單，因此如果你只需對一個流進行壓縮的話，可以使用它。當然它可以壓縮字符流，與可以壓縮字節流，下面是一個對GBK編碼格式的文本文件進行壓縮的。
壓縮類的用法非常簡單；只要用GZIPOutputStream 或ZipOutputStream把輸出流包起來，再用GZIPInputStream 或ZipInputStream把輸入流包起來就行了。剩下的都是些普通的I/O操作。

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GZIPcompress {
    public static void main(String[] args) throws IOException {
        //做準備壓縮一個字符文件，注，這裏的字符文件要是GBK編碼方式的
        BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(
                "e:/tmp/source.txt"), "GBK"));
        //使用GZIPOutputStream包裝OutputStream流，使其具體壓縮特性，最後會生成test.txt.gz壓縮包
        //並且裏面有一個名爲test.txt的文件
        BufferedOutputStream out = new BufferedOutputStream(new GZIPOutputStream(
                new FileOutputStream("test.txt.gz")));
        System.out.println("開始寫壓縮文件...");
        int c;
        while ((c = in.read()) != -1) {

            /*
             * 注，這裏是壓縮一個字符文件，前面是以字符流來讀的，不能直接存入c，因爲c已是Unicode
             * 碼，這樣會丟掉信息的（當然本身編碼格式就不對），所以這裏要以GBK來解後再存入。
             */
            out.write(String.valueOf((char) c).getBytes("GBK"));
        }
        in.close();
        out.close();
        System.out.println("開始讀壓縮文件...");
        //使用GZIPInputStream包裝InputStream流，使其具有解壓特性
        BufferedReader in2 = new BufferedReader(new InputStreamReader(
                new GZIPInputStream(new FileInputStream("test.txt.gz")), "GBK"));
        String s;
        //讀取壓縮文件裏的內容
        while ((s = in2.readLine()) != null) {
            System.out.println(s);
        }
        in2.close();
    }
}

使用Zip進行多個文件壓縮

Java對Zip格式類庫支持得比較全面，得用它可以把多個文件壓縮成一個壓縮包。這個類庫使用的是標準Zip格式，所以能與很多的壓縮工具兼容。

ZipOutputStream類有設置壓縮方法以及在壓縮方式下使用的壓縮級別，zipOutputStream.setMethod(int method)設置用於條目的默認壓縮方法。只要沒有爲單個 ZIP 文件條目指定壓縮方法，就使用ZipOutputStream所設置的壓縮方法來存儲，默認值爲 ZipOutputStream.DEFLATED（表示進行壓縮存儲），還可以設置成STORED（表示僅打包歸檔存儲）。 ZipOutputStream在設置了壓縮方法爲DEFLATED後，我們還可以進一步使用setLevel(int level)方法來設置壓縮級別，壓縮級別值爲0-9共10個級別(值越大，表示壓縮越利害)，默認爲 Deflater.DEFAULT_COMPRESSION=-1。當然我們也可以通過條目ZipEntry的setMethod方法爲單個條件設置壓縮 方法。

類ZipEntry描述了存儲在ZIP文件中的壓縮文件。類中包含有多種方法可以用來設置和獲得ZIP條目的信息。類ZipEntry是被 ZipFile[zipFile.getInputStream(ZipEntry entry)]和ZipInputStream使用來讀取ZIP文件，ZipOutputStream來寫入ZIP文件的。有以下這些有用的方 法：getName()返回條目名稱、isDirectory()如果爲目錄條目，則返回 true（目錄條目定義爲其名稱以 '/' 結尾的條目）、setMethod(int method) 設置條目的壓縮方法，可以爲 ZipOutputStream.STORED 或 ZipOutputStream .DEFLATED。

 

下面實例我們使用了apache的zip工具包（所在包爲ant.jar ），因爲java類型自帶的不支持中文路徑，不過兩者使用的方式是一樣的，只是apache壓縮工具多了設置編碼方式的接口，其他基本上是一樣的。另外， 如果使用org.apache.tools.zip.ZipOutputStream來壓縮的話，我們只能使用 org.apache.tools.zip.ZipEntry來解壓，而不能使用java.util.zip.ZipInputStream來解壓讀取 了，當然apache並未提供ZipInputStream類。

 

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.util.Enumeration;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.CheckedOutputStream;
import java.util.zip.Deflater;
import java.util.zip.ZipException;
import java.util.zip.ZipInputStream;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;

/**
 *
 * 提供對單個文件與目錄的壓縮，並支持是否需要創建壓縮源目錄、中文路徑
 *
 * @author jzj
 */
public class ZipCompress {

    private static boolean isCreateSrcDir = true;//是否創建源目錄

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        String src = "m:/新建文本文檔.txt";//指定壓縮源，可以是目錄或文件
        String decompressDir = "e:/tmp/decompress";//解壓路徑
        String archive = "e:/tmp/test.zip";//壓縮包路徑
        String comment = "Java Zip 測試.";//壓縮包註釋

        //----壓縮文件或目錄
        writeByApacheZipOutputStream(src, archive, comment);

        /*
         * 讀壓縮文件，註釋掉，因爲使用的是apache的壓縮類，所以使用java類庫中
         * 解壓類時出錯，這裏不能運行
         */
        //readByZipInputStream();
        //----使用apace ZipFile讀取壓縮文件
        readByApacheZipFile(archive, decompressDir);
    }

    public static void writeByApacheZipOutputStream(String src, String archive,
            String comment) throws FileNotFoundException, IOException {
        //----壓縮文件：
        FileOutputStream f = new FileOutputStream(archive);
        //使用指定校驗和創建輸出流
        CheckedOutputStream csum = new CheckedOutputStream(f, new CRC32());

        ZipOutputStream zos = new ZipOutputStream(csum);
        //支持中文
        zos.setEncoding("GBK");
        BufferedOutputStream out = new BufferedOutputStream(zos);
        //設置壓縮包註釋
        zos.setComment(comment);
        //啓用壓縮
        zos.setMethod(ZipOutputStream.DEFLATED);
        //壓縮級別爲最強壓縮，但時間要花得多一點
        zos.setLevel(Deflater.BEST_COMPRESSION);

        File srcFile = new File(src);

        if (!srcFile.exists() || (srcFile.isDirectory() && srcFile.list().length == 0)) {
            throw new FileNotFoundException(
                    "File must exist and  ZIP file must have at least one entry.");
        }
        //獲取壓縮源所在父目錄
        src = src.replaceAll("\\\\", "/");
        String prefixDir = null;
        if (srcFile.isFile()) {
            prefixDir = src.substring(0, src.lastIndexOf("/") + 1);
        } else {
            prefixDir = (src.replaceAll("/$", "") + "/");
        }

        //如果不是根目錄
        if (prefixDir.indexOf("/") != (prefixDir.length() - 1) && isCreateSrcDir) {
            prefixDir = prefixDir.replaceAll("[^/]+/$", "");
        }

        //開始壓縮
        writeRecursive(zos, out, srcFile, prefixDir);

        out.close();
        // 注：校驗和要在流關閉後才準備，一定要放在流被關閉後使用
        System.out.println("Checksum: " + csum.getChecksum().getValue());
        BufferedInputStream bi;
    }

    /**
     * 使用 org.apache.tools.zip.ZipFile 解壓文件，它與 java 類庫中的
     * java.util.zip.ZipFile 使用方式是一新的，只不過多了設置編碼方式的
     * 接口。
     *
     * 注，apache 沒有提供 ZipInputStream 類，所以只能使用它提供的ZipFile
     * 來讀取壓縮文件。
     * @param archive 壓縮包路徑
     * @param decompressDir 解壓路徑
     * @throws IOException
     * @throws FileNotFoundException
     * @throws ZipException
     */
    public static void readByApacheZipFile(String archive, String decompressDir)
            throws IOException, FileNotFoundException, ZipException {
        BufferedInputStream bi;

        ZipFile zf = new ZipFile(archive, "GBK");//支持中文

        Enumeration e = zf.getEntries();
        while (e.hasMoreElements()) {
            ZipEntry ze2 = (ZipEntry) e.nextElement();
            String entryName = ze2.getName();
            String path = decompressDir + "/" + entryName;
            if (ze2.isDirectory()) {
                System.out.println("正在創建解壓目錄 - " + entryName);
                File decompressDirFile = new File(path);
                if (!decompressDirFile.exists()) {
                    decompressDirFile.mkdirs();
                }
            } else {
                System.out.println("正在創建解壓文件 - " + entryName);
                String fileDir = path.substring(0, path.lastIndexOf("/"));
                File fileDirFile = new File(fileDir);
                if (!fileDirFile.exists()) {
                    fileDirFile.mkdirs();
                }
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(
                        decompressDir + "/" + entryName));

                bi = new BufferedInputStream(zf.getInputStream(ze2));
                byte[] readContent = new byte[1024];
                int readCount = bi.read(readContent);
                while (readCount != -1) {
                    bos.write(readContent, 0, readCount);
                    readCount = bi.read(readContent);
                }
                bos.close();
            }
        }
        zf.close();
    }

    /**
     * 使用 java api 中的 ZipInputStream 類解壓文件，但如果壓縮時採用了
     * org.apache.tools.zip.ZipOutputStream時，而不是 java 類庫中的
     * java.util.zip.ZipOutputStream時，該方法不能使用，原因就是編碼方
     * 式不一致導致，運行時會拋如下異常：
     * java.lang.IllegalArgumentException
     * at java.util.zip.ZipInputStream.getUTF8String(ZipInputStream.java:290)
     *
     * 當然，如果壓縮包使用的是java類庫的java.util.zip.ZipOutputStream
     * 壓縮而成是不會有問題的，但它不支持中文
     *
     * @param archive 壓縮包路徑
     * @param decompressDir 解壓路徑
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static void readByZipInputStream(String archive, String decompressDir)
            throws FileNotFoundException, IOException {
        BufferedInputStream bi;
        //----解壓文件(ZIP文件的解壓縮實質上就是從輸入流中讀取數據):
        System.out.println("開始讀壓縮文件");

        FileInputStream fi = new FileInputStream(archive);
        CheckedInputStream csumi = new CheckedInputStream(fi, new CRC32());
        ZipInputStream in2 = new ZipInputStream(csumi);
        bi = new BufferedInputStream(in2);
        java.util.zip.ZipEntry ze;//壓縮文件條目
        //遍歷壓縮包中的文件條目
        while ((ze = in2.getNextEntry()) != null) {
            String entryName = ze.getName();
            if (ze.isDirectory()) {
                System.out.println("正在創建解壓目錄 - " + entryName);
                File decompressDirFile = new File(decompressDir + "/" + entryName);
                if (!decompressDirFile.exists()) {
                    decompressDirFile.mkdirs();
                }
            } else {
                System.out.println("正在創建解壓文件 - " + entryName);
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(
                        decompressDir + "/" + entryName));
                byte[] buffer = new byte[1024];
                int readCount = bi.read(buffer);

                while (readCount != -1) {
                    bos.write(buffer, 0, readCount);
                    readCount = bi.read(buffer);
                }
                bos.close();
            }
        }
        bi.close();
        System.out.println("Checksum: " + csumi.getChecksum().getValue());
    }

    /**
     * 遞歸壓縮
     *
     * 使用 org.apache.tools.zip.ZipOutputStream 類進行壓縮，它的好處就是支持中文路徑，
     * 而Java類庫中的 java.util.zip.ZipOutputStream 壓縮中文文件名時壓縮包會出現亂碼。
     * 使用 apache 中的這個類與 java 類庫中的用法是一新的，只是能設置編碼方式了。
     *
     * @param zos
     * @param bo
     * @param srcFile
     * @param prefixDir
     * @throws IOException
     * @throws FileNotFoundException
     */
    private static void writeRecursive(ZipOutputStream zos, BufferedOutputStream bo,
            File srcFile, String prefixDir) throws IOException, FileNotFoundException {
        ZipEntry zipEntry;

        String filePath = srcFile.getAbsolutePath().replaceAll("\\\\", "/").replaceAll(
                "//", "/");
        if (srcFile.isDirectory()) {
            filePath = filePath.replaceAll("/$", "") + "/";
        }
        String entryName = filePath.replace(prefixDir, "").replaceAll("/$", "");
        if (srcFile.isDirectory()) {
            if (!"".equals(entryName)) {
                System.out.println("正在創建目錄 - " + srcFile.getAbsolutePath()
                        + "  entryName=" + entryName);

                //如果是目錄，則需要在寫目錄後面加上 /
                zipEntry = new ZipEntry(entryName + "/");
                zos.putNextEntry(zipEntry);
            }

            File srcFiles[] = srcFile.listFiles();
            for (int i = 0; i < srcFiles.length; i++) {
                writeRecursive(zos, bo, srcFiles[i], prefixDir);
            }
        } else {
            System.out.println("正在寫文件 - " + srcFile.getAbsolutePath() + "  entryName="
                    + entryName);
            BufferedInputStream bi = new BufferedInputStream(new FileInputStream(srcFile));

            //開始寫入新的ZIP文件條目並將流定位到條目數據的開始處
            zipEntry = new ZipEntry(entryName);
            zos.putNextEntry(zipEntry);
            byte[] buffer = new byte[1024];
            int readCount = bi.read(buffer);

            while (readCount != -1) {
                bo.write(buffer, 0, readCount);
                readCount = bi.read(buffer);
            }
            //注，在使用緩衝流寫壓縮文件時，一個條件完後一定要刷新一把，不
            //然可能有的內容就會存入到後麪條目中去了
            bo.flush();
            //文件讀完後關閉
            bi.close();
        }
    }
}

要想把文件加入壓縮包，你必須將ZipEntry對象傳給 putNextEntry( )。ZipEntry是一個接口很複雜的對象，它能讓你設置和讀取Zip文件裏的某條記錄的信息，這些信息包括：文件名，壓縮前和壓縮後的大小，日 期，CRC校驗碼，附加字段，註釋，壓縮方法，是否是目錄。雖然標準的Zip格式是支持口令的，但是Java的Zip類庫卻不支持。而且ZipEntry 卻只提供了CRC的接口，而CheckedInputStream和CheckedOutputStream卻支持Adler32和CRC32兩種校驗 碼。雖然這是底層的Zip格式的限制，但卻妨礙了你使用更快的Adler32了。

要想提取文件，可以用ZipInputStream的getNextEntry( )方法。只要壓縮包裏還有ZipEntry，它就會把它提取出來。此外還有一個更簡潔的辦法，你可以用ZipFile對象去讀文件。ZipFile有一個 entries()方法，它可以返回ZipEntries的Enumeration。然後通過zipFile. getInputStream(ZipEntry entry)獲取壓縮流就可以讀取相應條目了。

要想讀取校驗碼，必須先獲取Checksum對象。我們這裏用的是CheckedOutputStream和CheckedInputStream，不過 你也可以使用Checksum。java.util.zip包中比較重要校驗算法類是Adler32和CRC32，它們實現了 java.util.zip.Checksum接口，並估算了壓縮數據的校驗和（checksum）。在運算速度方面，Adler32算法比CRC32算 法要有一定的優勢；但在數據可信度方面，CRC32算法則要更勝一籌。GetValue方法可以用來獲得當前的checksum值，reset方法能夠重 新設置checksum爲其缺省的值。

校驗和一般用來校驗文件和信息是否正確的傳送。舉個例子，假設你想創建一個ZIP文件，然後將其傳送到遠程計算機上。當到達遠程計算機後，你就可以使用checksum檢驗在傳輸過程中文件是否發生錯誤，有點像下載文件後我們可以使用哈希值來校驗文件下載過程是否出錯了。

Zip類裏還有一個讓人莫名其妙的setComment( )方法。如ZipCompress.java所示，寫文件的時候，你可以加註釋，但是讀文件的時候，ZipInputSream卻不提供接口。看來它的註釋功能完全是針對條目的，是用ZipEntry實現的。

當然，GZIP和Zip不光能用來壓縮文件——它還能壓縮任何東西，包括要通過網絡傳輸的數據。