java zip API實現壓縮和解壓縮zip包

    package zip;  
      
    import java.io.BufferedInputStream;  
    import java.io.BufferedOutputStream;  
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.util.Enumeration;  
    import java.util.zip.CRC32;  
    import java.util.zip.CheckedOutputStream;  
    import java.util.zip.ZipEntry;  
    import java.util.zip.ZipFile;  
    import java.util.zip.ZipOutputStream;  
      
    import org.apache.commons.lang3.StringUtils;  
      
    public class ZipUtil {  
          
        /** 
         * 遞歸壓縮文件夾 
         * @param srcRootDir 壓縮文件夾根目錄的子路徑 
         * @param file 當前遞歸壓縮的文件或目錄對象 
         * @param zos 壓縮文件存儲對象 
         * @throws Exception 
         */  
        private static void zip(String srcRootDir, File file, ZipOutputStream zos) throws Exception  
        {  
            if (file == null)   
            {  
                return;  
            }                 
              
            //如果是文件，則直接壓縮該文件  
            if (file.isFile())  
            {             
                int count, bufferLen = 1024;  
                byte data[] = new byte[bufferLen];  
                  
                //獲取文件相對於壓縮文件夾根目錄的子路徑  
                String subPath = file.getAbsolutePath();  
                int index = subPath.indexOf(srcRootDir);  
                if (index != -1)   
                {  
                    subPath = subPath.substring(srcRootDir.length() + File.separator.length());  
                }  
                ZipEntry entry = new ZipEntry(subPath);  
                zos.putNextEntry(entry);  
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));  
                while ((count = bis.read(data, 0, bufferLen)) != -1)   
                {  
                    zos.write(data, 0, count);  
                }  
                bis.close();  
                zos.closeEntry();  
            }  
            //如果是目錄，則壓縮整個目錄  
            else   
            {  
                //壓縮目錄中的文件或子目錄  
                File[] childFileList = file.listFiles();  
                for (int n=0; n<childFileList.length; n++)  
                {  
                    childFileList[n].getAbsolutePath().indexOf(file.getAbsolutePath());  
                    zip(srcRootDir, childFileList[n], zos);  
                }  
            }  
        }  
          
        /** 
         * 對文件或文件目錄進行壓縮 
         * @param srcPath 要壓縮的源文件路徑。如果壓縮一個文件，則為該文件的全路徑；如果壓縮一個目錄，則為該目錄的頂層目錄路徑 
         * @param zipPath 壓縮文件保存的路徑。注意：zipPath不能是srcPath路徑下的子文件夾 
         * @param zipFileName 壓縮文件名 
         * @throws Exception 
         */  
        public static void zip(String srcPath, String zipPath, String zipFileName) throws Exception  
        {  
            if (StringUtils.isEmpty(srcPath) || StringUtils.isEmpty(zipPath) || StringUtils.isEmpty(zipFileName))  
            {  
                throw new ParameterException(ICommonResultCode.PARAMETER_IS_NULL);  
            }  
            CheckedOutputStream cos = null;  
            ZipOutputStream zos = null;                       
            try  
            {  
                File srcFile = new File(srcPath);  
                  
                //判斷壓縮文件保存的路徑是否為源文件路徑的子文件夾，如果是，則拋出異常（防止無限遞歸壓縮的發生）  
                if (srcFile.isDirectory() && zipPath.indexOf(srcPath)!=-1)   
                {  
                    throw new ParameterException(ICommonResultCode.INVALID_PARAMETER, "zipPath must not be the child directory of srcPath.");  
                }  
                  
                //判斷壓縮文件保存的路徑是否存在，如果不存在，則創建目錄  
                File zipDir = new File(zipPath);  
                if (!zipDir.exists() || !zipDir.isDirectory())  
                {  
                    zipDir.mkdirs();  
                }  
                  
                //創建壓縮文件保存的文件對象  
                String zipFilePath = zipPath + File.separator + zipFileName;  
                File zipFile = new File(zipFilePath);             
                if (zipFile.exists())  
                {  
                    //檢測文件是否允許刪除，如果不允許刪除，將會拋出SecurityException  
                    SecurityManager securityManager = new SecurityManager();  
                    securityManager.checkDelete(zipFilePath);  
                    //刪除已存在的目標文件  
                    zipFile.delete();                 
                }  
                  
                cos = new CheckedOutputStream(new FileOutputStream(zipFile), new CRC32());  
                zos = new ZipOutputStream(cos);  
                  
                //如果只是壓縮一個文件，則需要截取該文件的父目錄  
                String srcRootDir = srcPath;  
                if (srcFile.isFile())  
                {  
                    int index = srcPath.lastIndexOf(File.separator);  
                    if (index != -1)  
                    {  
                        srcRootDir = srcPath.substring(0, index);  
                    }  
                }  
                //調用遞歸壓縮方法進行目錄或文件壓縮  
                zip(srcRootDir, srcFile, zos);  
                zos.flush();  
            }  
            catch (Exception e)   
            {  
                throw e;  
            }  
            finally   
            {             
                try  
                {  
                    if (zos != null)  
                    {  
                        zos.close();  
                    }                 
                }  
                catch (Exception e)  
                {  
                    e.printStackTrace();  
                }             
            }  
        }  
          
        /** 
         * 解壓縮zip包 
         * @param zipFilePath zip文件的全路徑 
         * @param unzipFilePath 解壓后的文件保存的路徑 
         * @param includeZipFileName 解壓后的文件保存的路徑是否包含壓縮文件的文件名。true-包含；false-不包含 
         */  
        @SuppressWarnings("unchecked")  
        public static void unzip(String zipFilePath, String unzipFilePath, boolean includeZipFileName) throws Exception  
        {  
            if (StringUtils.isEmpty(zipFilePath) || StringUtils.isEmpty(unzipFilePath))  
            {  
                throw new ParameterException(ICommonResultCode.PARAMETER_IS_NULL);            
            }  
            File zipFile = new File(zipFilePath);  
            //如果解壓后的文件保存路徑包含壓縮文件的文件名，則追加該文件名到解壓路徑  
            if (includeZipFileName)  
            {  
                String fileName = zipFile.getName();  
                if (StringUtils.isNotEmpty(fileName))  
                {  
                    fileName = fileName.substring(0, fileName.lastIndexOf("."));  
                }  
                unzipFilePath = unzipFilePath + File.separator + fileName;  
            }  
            //創建解壓縮文件保存的路徑  
            File unzipFileDir = new File(unzipFilePath);  
            if (!unzipFileDir.exists() || !unzipFileDir.isDirectory())  
            {  
                unzipFileDir.mkdirs();  
            }  
              
            //開始解壓  
            ZipEntry entry = null;  
            String entryFilePath = null, entryDirPath = null;  
            File entryFile = null, entryDir = null;  
            int index = 0, count = 0, bufferSize = 1024;  
            byte[] buffer = new byte[bufferSize];  
            BufferedInputStream bis = null;  
            BufferedOutputStream bos = null;  
            ZipFile zip = new ZipFile(zipFile);  
            Enumeration<ZipEntry> entries = (Enumeration<ZipEntry>)zip.entries();  
            //循環對壓縮包里的每一個文件進行解壓       
            while(entries.hasMoreElements())  
            {  
                entry = entries.nextElement();  
                //構建壓縮包中一個文件解壓后保存的文件全路徑  
                entryFilePath = unzipFilePath + File.separator + entry.getName();  
                //構建解壓后保存的文件夾路徑  
                index = entryFilePath.lastIndexOf(File.separator);  
                if (index != -1)  
                {  
                    entryDirPath = entryFilePath.substring(0, index);  
                }  
                else  
                {  
                    entryDirPath = "";  
                }             
                entryDir = new File(entryDirPath);  
                //如果文件夾路徑不存在，則創建文件夾  
                if (!entryDir.exists() || !entryDir.isDirectory())  
                {  
                    entryDir.mkdirs();  
                }  
                  
                //創建解壓文件  
                entryFile = new File(entryFilePath);  
                if (entryFile.exists())  
                {  
                    //檢測文件是否允許刪除，如果不允許刪除，將會拋出SecurityException  
                    SecurityManager securityManager = new SecurityManager();  
                    securityManager.checkDelete(entryFilePath);  
                    //刪除已存在的目標文件  
                    entryFile.delete();   
                }  
                  
                //寫入文件  
                bos = new BufferedOutputStream(new FileOutputStream(entryFile));  
                bis = new BufferedInputStream(zip.getInputStream(entry));  
                while ((count = bis.read(buffer, 0, bufferSize)) != -1)  
                {  
                    bos.write(buffer, 0, count);  
                }  
                bos.flush();  
                bos.close();              
            }  
        }  
          
        public static void main(String[] args)   
        {  
            String zipPath = "d:\\ziptest\\zipPath";  
            String dir = "d:\\ziptest\\rawfiles";  
            String zipFileName = "test.zip";  
            try  
            {  
                zip(dir, zipPath, zipFileName);  
            }   
            catch (Exception e)  
            {  
                e.printStackTrace();  
            }  
              
            String zipFilePath = "D:\\ziptest\\zipPath\\test.zip";  
            String unzipFilePath = "D:\\ziptest\\zipPath";  
            try   
            {  
                unzip(zipFilePath, unzipFilePath, true);  
            }  
            catch (Exception e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }