java使用ant实现Zip文件压缩、解压缩Zip文件。
 
单个文件压缩成Zip文件，多个文件压缩成Zip文件。
 
可以压缩大文件。
 
 
需要使用到ant.jar文件，放到lib目录下。
 
ant.jar下载：http://download.csdn.net/detail/xinxin19881112/8906157
 

 
 
Zip.java
 
 
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.zip.ZipOutputStream;
import org.apache.tools.zip.ZipEntry;

/**
 * ZIP操作工具类
 */
public class Zip {
	
	/**
	 * 压缩文件列表到某ZIP文件
	 * @param zipFilename 要压缩到的ZIP文件
	 * @param paths 文件列表，多参数
	 * @throws Exception
	 */
	public static void compress(String zipFilename, String... paths)
			throws Exception {
		compress(new FileOutputStream(zipFilename), paths);
	}

	/**
	 * 压缩文件列表到输出流
	 * @param os 要压缩到的流
	 * @param paths 文件列表，多参数
	 * @throws Exception
	 */
	public static void compress(OutputStream os, String... paths)
			throws Exception {
		ZipOutputStream zos = new ZipOutputStream(os);
		for (String path : paths) {
			if (path.equals(""))
				continue;
			java.io.File file = new java.io.File(path);
			if (file.exists()) {
				if (file.isDirectory()) {
					zipDirectory(zos, file.getPath(), file.getName()
							+ File.separator);
				} else {
					zipFile(zos, file.getPath(), "");
				}
			}
		}
		zos.close();
	}
	
	private static void zipDirectory(ZipOutputStream zos, String dirName,
			String basePath) throws Exception {
		File dir = new File(dirName);
		if (dir.exists()) {
			File files[] = dir.listFiles();
			if (files.length > 0) {
				for (File file : files) {
					if (file.isDirectory()) {
						zipDirectory(zos, file.getPath(), basePath
								+ file.getName().substring(
										file.getName().lastIndexOf(
												File.separator) + 1)
								+ File.separator);
					} else
						zipFile(zos, file.getPath(), basePath);
				}
			} else {
				ZipEntry ze = new ZipEntry(basePath);
				zos.putNextEntry(ze);
			}
		}
	}

	private static void zipFile(ZipOutputStream zos, String filename,
			String basePath) throws Exception {
		File file = new File(filename);
		if (file.exists()) {
			FileInputStream fis = new FileInputStream(filename);
			ZipEntry ze = new ZipEntry(basePath + file.getName());
			zos.putNextEntry(ze);
			byte[] buffer = new byte[8192];
			int count = 0;
			while ((count = fis.read(buffer)) > 0) {
				zos.write(buffer, 0, count);
			}
			fis.close();
		}
	}
}

 

 
 

 
 
TestCompress.java
 
 
 
import java.io.FileOutputStream;

import com.xx.commmon.Zip;

/**
 * 压缩文件测试
 */
public class TestCompress {

	public static void main(String[] args) {
		// 要压缩的文件列表
		String path01 = "E:\\下载\\cn_windows_8_x86_dvd_915414.iso";
		String path02 = "e:\\PPT模版_V0.1.potx";
		try {
			FileOutputStream os = new FileOutputStream("e:\\测试.zip"); // 输出的ZIP文件流
			Zip.compress(os, path01);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

 

 
 

 
 
TestEctractZip.java
 
 
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

/**
 * 解压缩测试
 */
public class TestEctractZip {

	@SuppressWarnings( { "unchecked", "static-access" })
	public static void main(String[] args) {
		TestEctractZip z = new TestEctractZip();
		ArrayList<String> a = z.Ectract("C:\\a.zip", "C:\\tmp\\"); // 返回解压缩出来的文件列表
		for(String s : a){
			System.out.println(s);
		}
	}

	/**
	 * 解压缩
	 * @param sZipPathFile 要解压的文件
	 * @param sDestPath 解压到某文件夹
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static ArrayList Ectract(String sZipPathFile, String sDestPath) {
		ArrayList<String> allFileName = new ArrayList<String>();
		try {
			// 先指定压缩档的位置和档名，建立FileInputStream对象
			FileInputStream fins = new FileInputStream(sZipPathFile);
			// 将fins传入ZipInputStream中
			ZipInputStream zins = new ZipInputStream(fins);
			ZipEntry ze = null;
			byte[] ch = new byte[256];
			while ((ze = zins.getNextEntry()) != null) {
				File zfile = new File(sDestPath + ze.getName());
				//File zfile = new File(sDestPath +File.separator+ ze.getName());
				File fpath = new File(zfile.getParentFile().getPath());
				if (ze.isDirectory()) {
					if (!zfile.exists())
						zfile.mkdirs();
					zins.closeEntry();
				} else {
					if (!fpath.exists())
						fpath.mkdirs();
					FileOutputStream fouts = new FileOutputStream(zfile);
					int i;
					allFileName.add(zfile.getAbsolutePath());
					while ((i = zins.read(ch)) != -1)
						fouts.write(ch, 0, i);
					zins.closeEntry();
					fouts.close();
				}
			}
			fins.close();
			zins.close();
		} catch (Exception e) {
			System.err.println("Extract error:" + e.getMessage());
		}
		return allFileName;
	}
}
 

 
 
新新：http://blog.csdn.net/xinxin19881112/article/details/46913931
 

zip文件格式
 
说明
 
本人根据自己的学习过程，适当理解，并作下笔记，以便查阅。这里暂不包含zip64部分。
 
整体结构
 
简单归纳总结下，zip文件格式由文件数据区、中央目录结构,中央目录结束标志组成。其中中央目录结束节又有一个字段保存了中央目录结构的偏移。整体结构如下图 
 

 

 
分区描述
 
中央目录结束标志
 
中央目录结束标志一般位于文件的末尾。由于它也有字段指向了中央目录开始处的偏移， 所以把它放在最前面描述。它被用来标识中央目录结束。可以通过读取它来找到中央目录并解析整个文件结构。该结构具体如下：
 
struct EndLocator
{
    ui32 signature;   //目录结束标记,(固定值0x06054b50)
    ui16 elDiskNumber;  //当前磁盘编号
    ui16 elStartDiskNumber;  //中央目录开始位置的磁盘编号
    ui16 elEntriesOnDisk;  //该磁盘上所记录的核心目录数量
    ui16 elEntriesInDirectory;  //中央目录结构总数
    ui32 elDirectorySize;  //中央目录的大小
    ui32 elDirectoryOffset;  //中央目录开始位置相对于文件头的偏移
    ui16 elCommentLen;  // 注释长度
    char *elComment;  // 注释内容
};
 
中央目录结构
 
中央目录结构位于文件数据区后，它用来保存所有文件的路径信息，和对应文件数据结构区在文件中的偏移。该结构具体如下：
 
struct DirEntry
{
    ui32 signature;  // 中央目录文件header标识（0x02014b50）
    ui16 deVersionMadeBy;  // 压缩所用的pkware版本
    ui16 deVersionToExtract;  // 解压所需pkware的最低版本
    ui16 deFlags;  // 通用位标记
    ui16 deCompression;  // 压缩方法
    ui16 deFileTime;  // 文件最后修改时间
    ui16 deFileDate;  // 文件最后修改日期
    ui32 deCrc;  // CRC-32校验码
    ui32 deCompressedSize;  // 压缩后的大小
    ui32 deUncompressedSize;  // 未压缩的大小
    ui16 deFileNameLength;  // 文件名长度
    ui16 deExtraFieldLength;  // 扩展域长度
    ui16 deFileCommentLength; // 文件注释长度
    ui16 deDiskNumberStart;  // 文件开始位置的磁盘编号
    ui16 deInternalAttributes;  // 内部文件属性
    ui32 deExternalAttributes;  // 外部文件属性
    ui32 deHeaderOffset;  // 本地文件头的相对位移
    char *deFileName;  // 目录文件名
    char *deExtraField;  // 扩展域
    char *deFileComment; // 文件注释内容
};
 
中央目录结构区是由中央目录结构的数组组成，这个结构只有目录文件名，扩展域，文件注释内容长度是不定的，并且可以在这个结构中获取它的长度，那么通过此就可以遍历出所有的文件。设当前中央目录结构偏移为current_offset,下个中央目录结构偏移为next_offset,则计算公式为：
 
next_offset = current_offset + sizeof(DirEntry) - 3*sizeof(char*) + deFileNameLength + deExtraFieldLength + deFileCommentLength;
 
其中CRC32校验码为对应的文件压缩数据的CRC32的校验码，如对应文件的数据压缩数据的CRC32与这里的值不同，则数据损坏。 
 通过中央目录结构的deHeaderOffset字段可以直接获取到对应文件的文件数据区结构的文件偏移，就可以直接获取到对应文件的压缩数据了。
 
文件数据区
 
文件数据区是保存所有压缩文件数据的区，它位于文件头，并由压缩数据结构的数组组成。其结构如下：
 
struct Record
{
    ui32 signature;  // 文件头标识，值固定(0x04034b50)
    ui16 frVersion;  // 解压文件所需 pkware最低版本
    ui16 frFlags;  // 通用比特标志位(置比特0位=加密)
    ui16 frCompression;  // 压缩方式
    ui16 frFileTime;  // 文件最后修改时间
    ui16 frFileDate;  //文件最后修改日期
    ui32 frCrc;  // CRC-32校验码
    ui32 frCompressedSize;  //  压缩后的大小
    ui32 frUncompressedSize;  // 未压缩的大小
    ui16 frFileNameLength;  //  文件名长度
    ui16 frExtraFieldLength;  // 扩展区长度
    char* frFileName;  // 文件名
    char* frExtraField;  // 扩展区
    char* frData; // 压缩数据
};
 
这里的压缩方式frCompression有如下取值：
 
          0 - The file is stored (no compression)
          1 - The file is Shrunk
          2 - The file is Reduced with compression factor 1
          3 - The file is Reduced with compression factor 2
          4 - The file is Reduced with compression factor 3
          5 - The file is Reduced with compression factor 4
          6 - The file is Imploded
          7 - Reserved for Tokenizing compression algorithm
          8 - The file is Deflated
          9 - Enhanced Deflating using Deflate64(tm)
         10 - PKWARE Data Compression Library Imploding
         11 - Reserved by PKWARE
         12 - File is compressed using BZIP2 algorithm
 
通过中央目录结构就可以找到文件数据结构，通过文件数据结构获取到压缩数据结构，并通过此结构可以获取到压缩的数据和使用的算法，并可以根据此解压出对应的数据。
 
crc32
 
crc32即循环冗余校验，一般用于校验数据是否正确。其实现方式参考http://blog.csdn.net/lickylin/article/details/7857586
 
总结
 
zip文件结构比较清晰，可以从位于文件尾的中央文件目录结束区入手，获取到中央目录结构的偏移地址，再遍历中央目录获取到所有的文件，并通过文件数据结构获取到文件数据，数据是否损坏可通过crc32进行校验。

学习Java压缩zip文件：
压缩单个文件和多个文件，不包含文件夹；
怎样用Java将文件追加到zip文件中。
测试类：
/**
 * @FileName:ZipTest.java
 * @Description: TODO
 * @Copyright: All rights Reserved, Designed By [meter] Copyright(C) 2010-2018
 * @Company: 
 * @author:meter
 * @version: V1.0 
 * @Create:2018年5月4日 上午9:50:22
 *
 * Modification  History:
 * Date         Author        Version        Discription
 * -----------------------------------------------------------------------------------
 * 2018年5月4日      meter          1.0             1.0
 * Why & What is modified: <修改原因描述>
 */
package org.meter.demo;

import java.io.File;
import java.io.FileFilter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.meter.zip.ZipTools;


/**      
 * @项目名称：meter   
 * @类名称：ZipTest   
 * @类描述：   
 * @创建人：meter   
 * @创建时间：2018年5月4日 上午9:50:22   
 * @版权：Copyright@2018.All Rights Reserved    
 * @version v1.0      
 */
public class ZipTest {
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddhhmmssSSSS");
	private static ThreadPoolExecutor workerPool=new ThreadPoolExecutor(20,
				25,
				1,
				TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(15),
				new ThreadPoolExecutor.CallerRunsPolicy());
		
	private static void test(String path,Long size) throws Exception{
		workerPool.allowCoreThreadTimeOut(true);// 设置超时时关闭线程
		File dir=new File(path);
		if(!dir.exists()){
			System.out.println("当前路径:"+path+"不存在");
			return;
		}
		System.out.println("当前路径:"+dir.getAbsolutePath());
		File[] files =dir.listFiles(new FileFilter(){
			@Override
			public boolean accept(File pathname) {
				if(pathname.getName().toLowerCase().endsWith(".zip")&&pathname.getName().toLowerCase().contains("sca_2018")){
					return true;
				}
				return false;
			}
		});
		long fileSize=0;
		List<File> fileList=new ArrayList<File>();
		String zipName="sca_"+sdf.format(new Date())+".zip";
		int flag=files.length;
		for(File file:files){
			System.out.println("读取到文件："+file.getName());
			fileSize+=file.length();
			fileList.add(file);
			flag--;
			if(fileSize>=size){
				workerPool.execute(new InnerWorker(fileList,zipName));
				fileSize=0;
				fileList=new ArrayList<File>();
				zipName="sca_"+sdf.format(new Date())+".zip";
			} else if(flag<=0){
				ZipTools.zipFiles(fileList,new File(zipName));
			}
		}
	}

    
    private static class InnerWorker implements Runnable{
    	private List<File> fileList;
    	private String zipName;
    	public InnerWorker(List<File> fileList,String zipName){
    		this.fileList=fileList;
    		this.zipName=zipName;
    	}
    	
		@Override
		public void run() {
			try {
				ZipTools.zipFiles(fileList,new File(zipName));
				System.out.println("压缩文件["+zipName+"]成功。");
			} catch (Exception e) {
				e.printStackTrace();
				System.out.println("压缩失败文件:"+zipName);
			}
			
		}
    	
    }
	/** @创建日期：2018年5月4日 上午9:50:22
	 * @作者： meter
	 * @描述：TODO
	 * @Title: main
	 * @param args   
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		System.out.println("Please input the path:");
		Scanner input = new Scanner(System.in);
		String path=input.nextLine();
		test(path,2147483648L);
	}

}



工具类：
/**
 * @FileName:ZipTools.java
 * @Description: TODO
 * @Copyright: All rights Reserved, Designed By [meter] Copyright(C) 2010-2018
 * @Company: 米特娱乐乐园
 * @author:meter
 * @version: V1.0 
 * @Create:2018年5月4日 上午10:25:09
 *
 * Modification  History:
 * Date         Author        Version        Discription
 * -----------------------------------------------------------------------------------
 * 2018年5月4日      meter          1.0             1.0
 * Why & What is modified: <修改原因描述>
 */
package org.meter.zip;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;



/**
 * @项目名称：meter
 * @类名称：ZipTools 
 * @类描述：采用zip压缩文件
 * @创建人：meter
 * @创建时间：2018年5月4日 上午10:25:09
 * @版权：Copyright@2018.All Rights Reserved
 * @version v1.0
 */
public class ZipTools {
	/**
	 * @创建日期：2018年5月4日 下午1:37:22
	 * @作者： meter
	 * @描述：压缩多个文件的情况
	 * @Title: zip
	 * @param fileList
	 * @param zipFile
	 * @throws Exception
	 */
	public static void zipFiles(List<File> fileList,File zipFile) throws Exception{
		System.out.println("zipFiles待压缩文件："+zipFile.getAbsolutePath());
		if(fileList != null){
			if(zipFile.exists()){//压缩文件已经存在，则只能单个添加
				for(File file:fileList){
					zip(zipFile,file);
				}
			}else{//不存在则新建
				// 创建zip输出流
				ZipOutputStream zipOutStream = new ZipOutputStream(new FileOutputStream(zipFile), Charset.forName("UTF-8"));
				// 创建缓冲输出流
				BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutStream);
				for(File file:fileList){
					zipFile(file,zipOutStream,bufferOutStream);
				}
				//最后关闭输出流
				bufferOutStream.close();
				zipOutStream.close();
			}
			
		}
	}
	/**
	 * @创建日期：2018年5月4日 下午1:44:55
	 * @作者： meter
	 * @描述：执行文件压缩
	 * @Title: zipFile
	 * @param file
	 * @param zipOutStream
	 * @param bufferOutStream
	 * @throws IOException
	 */
	private static void zipFile(File file,ZipOutputStream zipOutStream,BufferedOutputStream bufferOutStream) throws IOException{
		// 创建压缩文件实体
		ZipEntry entry = new ZipEntry(file.getName());
		// 添加实体
		zipOutStream.putNextEntry(entry);
		// 创建输入流
		BufferedInputStream bufferInputStream = new BufferedInputStream(new FileInputStream(file));
		write(bufferInputStream, bufferOutStream);
		zipOutStream.closeEntry();
	}
	/**
	 * @创建日期：2018年5月4日 下午1:37:01
	 * @作者： meter
	 * @描述：压缩单个文件
	 * @Title: zip
	 * @param zipFile
	 * @param sourceFile
	 * @throws Exception
	 */
	public static void zip(File zipFile, File sourceFile) throws Exception {
		System.out.println("待压缩文件："+zipFile.getAbsolutePath());
		if (zipFile.exists()) {// 添加到已经存在的压缩文件中
			
			File tempFile=new File(zipFile.getAbsolutePath()+".tmp");
			// 创建zip输出流
			ZipOutputStream zipOutStream = new ZipOutputStream(new FileOutputStream(tempFile), Charset.forName("UTF-8"));
			// 创建缓冲输出流
			BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutStream);
			ZipFile zipOutFile = new ZipFile(zipFile);
			
			Enumeration<? extends ZipEntry> entries = zipOutFile.entries();
			while (entries.hasMoreElements()) {
				ZipEntry entry = entries.nextElement();
				System.out.println("copy: " + entry.getName());
				zipOutStream.putNextEntry(entry);
				if (!entry.isDirectory()) {
					write(zipOutFile.getInputStream(entry), bufferOutStream);
				}
				zipOutStream.closeEntry();
			}
			zipOutFile.close();//记得关闭zip文件，否则后面无法删除原始文件
			ZipEntry entry = new ZipEntry(sourceFile.getName());
			// 添加实体
			zipOutStream.putNextEntry(entry);
			BufferedInputStream bufferInputStream = new BufferedInputStream(new FileInputStream(sourceFile));
			write(bufferInputStream, bufferOutStream);
			//最后关闭输出流
			bufferOutStream.close();
			zipOutStream.close();
			boolean flag=zipFile.delete();
			if(flag){
			tempFile.renameTo(zipFile);
			}else{
				System.out.println("删除文件失败。");
			}
		} else {// 新创建压缩文件
			// 创建zip输出流
			ZipOutputStream zipOutStream = new ZipOutputStream(new FileOutputStream(zipFile), Charset.forName("UTF-8"));
			// 创建缓冲输出流
			BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutStream);
			// 创建压缩文件实体
			ZipEntry entry = new ZipEntry(sourceFile.getName());
			// 添加实体
			zipOutStream.putNextEntry(entry);
			// 创建输入流
			BufferedInputStream bufferInputStream = new BufferedInputStream(new FileInputStream(sourceFile));
			write(bufferInputStream, bufferOutStream);
			//最后关闭输出流
			bufferOutStream.close();
			zipOutStream.close();
		}
		
	}
	/**
	 * @创建日期：2018年5月4日 下午2:09:37
	 * @作者： meter
	 * @描述：读写zip文件
	 * @Title: write
	 * @param inputStream
	 * @param outStream
	 * @throws IOException
	 */
    private static void write(InputStream inputStream,OutputStream outStream) throws IOException{
    	byte[] data=new byte[4096];
    	int length=0;
    	while((length=inputStream.read(data)) != -1){
    		outStream.write(data,0,length);
    	}
    	outStream.flush();//刷新输出流
    	inputStream.close();//关闭输入流
    }
    
    /**
     * @创建日期：2018年5月4日 下午3:07:55
     * @作者： meter
     * @描述：压缩指定目录下所有文件
     * @Title: zipDirectory
     * @param dirFile
     * @param zipFile
     * @throws IOException 
     */
    public static void zipDirectory(File dirFile,File zipFile) throws IOException{
    	if(dirFile != null && dirFile.isDirectory()){
    		if(zipFile == null){
    			zipFile=new File(dirFile.getAbsolutePath()+".zip");
    		}
    		String dirName=dirFile.getName()+File.separator;
    		// 创建zip输出流
			ZipOutputStream zipOutStream = new ZipOutputStream(new FileOutputStream(zipFile), Charset.forName("UTF-8"));
			// 创建缓冲输出流
			BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutStream);
			dealDirFile( dirFile,dirName,bufferOutStream,zipOutStream);
			
			//最后关闭输出流
			bufferOutStream.close();
			zipOutStream.close();
    	}else{
    		System.out.println("["+dirFile.getName()+"]不是一个文件夹,或者不存在。");
    	}
    }
    /**
     * @创建日期：2018年5月4日 下午4:38:46
     * @作者： meter
     * @描述：处理目录文件
     * @Title: dealDirFile
     * @param dirFile
     * @param parentDir
     * @param bufferOutStream
     * @param zipOutStream
     * @throws IOException
     */
    private static void dealDirFile(File dirFile,String parentDir, BufferedOutputStream bufferOutStream, ZipOutputStream zipOutStream) throws IOException{
    	File[] fileList=dirFile.listFiles();
    	for(File file:fileList){
    		if(file.isFile()){
    			// 创建压缩文件实体
    			ZipEntry entry = new ZipEntry(parentDir+file.getName());
    			// 添加实体
    			zipOutStream.putNextEntry(entry);
    			// 创建输入流
    			BufferedInputStream bufferInputStream = new BufferedInputStream(new FileInputStream(file));
    			write(bufferInputStream, bufferOutStream);
    		}else{
    			dealDirFile(file,  parentDir+file.getName()+File.separator,  bufferOutStream,  zipOutStream);
    		}
    	}
    }
    /**
     * @创建日期：2018年5月4日 下午3:22:11
     * @作者： meter
     * @描述：重载zipDirectory
     * @Title: zipDirectory
     * @param dirPath
     * @param zipPath
     * @throws IOException
     */
    public static void zipDirectory(String dirPath,String zipPath) throws IOException{
    	if(zipPath==null || "".equals(zipPath)){
    		zipDirectory(new File(dirPath),null);
    	}else{
    		zipDirectory(new File(dirPath),new File(zipPath));
    	}
    }
   //------------------------------------------------米特华丽的分割线----------------------------------------------------------------------------------------
   
    /**
     * @创建日期：2018年5月4日 下午4:00:41
     * @作者： meter
     * @描述：解压文件
     * @Title: unzip
     * @param zipFile
     * @param destDir
     * @throws IOException 
     */
	public static void unzip(File zipFile, File destDir) throws IOException {
		ZipFile zipOutFile = new ZipFile(zipFile,Charset.forName("gbk"));
		Enumeration<? extends ZipEntry> entries = zipOutFile.entries();
		while (entries.hasMoreElements()) {
			ZipEntry entry = entries.nextElement();
			if(entry.isDirectory()){
				File tempFile = new File(destDir.getAbsolutePath()+File.separator+entry.getName());
				if (!tempFile.exists()) {
					tempFile.mkdirs();
				}
			}else{
				File tempFile=new File(destDir.getAbsolutePath()+File.separator+entry.getName());
				checkParentDir(tempFile);
				FileOutputStream fileOutStream=new FileOutputStream(tempFile);
				BufferedOutputStream bufferOutStream = new BufferedOutputStream(fileOutStream);
				write(zipOutFile.getInputStream(entry),bufferOutStream);
				bufferOutStream.close();
				fileOutStream.close();
			}
		}
		zipOutFile.close();//记得关闭zip文件
	}
	
	/**
	 * @创建日期：2018年5月4日 下午4:37:41
	 * @作者： meter
	 * @描述：验证父目录是否存在，否则创建
	 * @Title: checkParentDir
	 * @param file
	 */
	private static void checkParentDir(File file){
		if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();
		}
	}
	
}

官方文档
 
https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.2.0.txt
 
格式说明
 
在官方文档中给出的ZIP格式如下：
 
  Overall .ZIP file format:

    [local file header 1]
    [file data 1]
    [data descriptor 1]
    . 
    .
    .
    [local file header n]
    [file data n]
    [data descriptor n]
    [archive decryption header] (EFS)
    [archive extra data record] (EFS)
    [central directory]
    [zip64 end of central directory record]
    [zip64 end of central directory locator] 
    [end of central directory record]
 
通常情况下，我们用到的ZIP文件格式：
 
[local file header + file data + data descriptor]{1,n} + central directory + end of central directory record
即
[文件头+文件数据+数据描述符]{此处可重复n次}+核心目录+目录结束标识

当压缩包中有多个文件时，就会有多个[文件头+文件数据+数据描述符]
 
本片文章讨论的就是这种通常用到的ZIP文件格式，若想了解完整的ZIP文件格式，请看官方文档。
 
压缩源文件数据区
 
[local file header + file data + data descriptor]
 
记录着压缩的所有文件的内容信息，每个压缩文件都由local file header 、file data、data descriptor三部分组成，在这个数据区中每一个压缩的源文件/目录都是一条记录。
 
### local file header 文件头
 用于标识该文件的开始，记录了该压缩文件的信息。
 
Offset
Bytes
Description
译
0
4
Local file header signature = 0x04034b50 (read as a little-endian number)
文件头标识，值固定(0x04034b50)
4
2
Version needed to extract (minimum)
解压文件所需 pkware最低版本
6
2
General purpose bit flag
通用比特标志位(置比特0位=加密，详情见后)
8
2
Compression method
压缩方式（详情见后）
10
2
File last modification time
文件最后修改时间
12
2
File last modification date
文件最后修改日期
14
4
CRC-32
CRC-32校验码
18
4
Compressed size
压缩后的大小
22
4
Uncompressed size
未压缩的大小
26
2
File name length (n)
文件名长度
28
2
Extra field length (m)
扩展区长度
30
n
File name
文件名
30+n
m
Extra field
扩展区
general purpose bit flag: (2 bytes) 通用位标记
 
      Bit 0: If set, indicates that the file is encrypted.

      (For Method 6 - Imploding)
      Bit 1: If the compression method used was type 6,
             Imploding, then this bit, if set, indicates
             an 8K sliding dictionary was used.  If clear,
             then a 4K sliding dictionary was used.
      Bit 2: If the compression method used was type 6,
             Imploding, then this bit, if set, indicates
             3 Shannon-Fano trees were used to encode the
             sliding dictionary output.  If clear, then 2
             Shannon-Fano trees were used.

      (For Methods 8 and 9 - Deflating)
      Bit 2  Bit 1
        0      0    Normal (-en) compression option was used.
        0      1    Maximum (-exx/-ex) compression option was used.
        1      0    Fast (-ef) compression option was used.
        1      1    Super Fast (-es) compression option was used.

      Note:  Bits 1 and 2 are undefined if the compression
             method is any other.

      Bit 3: If this bit is set, the fields crc-32, compressed 
             size and uncompressed size are set to zero in the 
             local header.  The correct values are put in the 
             data descriptor immediately following the compressed
             data.  (Note: PKZIP version 2.04g for DOS only 
             recognizes this bit for method 8 compression, newer 
             versions of PKZIP recognize this bit for any 
             compression method.)

      Bit 4: Reserved for use with method 8, for enhanced
             deflating. 

      Bit 5: If this bit is set, this indicates that the file is 
             compressed patched data.  (Note: Requires PKZIP 
             version 2.70 or greater)

      Bit 6: Strong encryption.  If this bit is set, you should
             set the version needed to extract value to at least
             50 and you must also set bit 0.  If AES encryption
             is used, the version needed to extract value must 
             be at least 51.

      Bit 7: Currently unused.

      Bit 8: Currently unused.

      Bit 9: Currently unused.

      Bit 10: Currently unused.

      Bit 11: Currently unused.

      Bit 12: Reserved by PKWARE for enhanced compression.

      Bit 13: Used when encrypting the Central Directory to indicate 
              selected data values in the Local Header are masked to
              hide their actual values.  See the section describing 
              the Strong Encryption Specification for details.

      Bit 14: Reserved by PKWARE.

      Bit 15: Reserved by PKWARE.
 
compression method: (2 bytes) 压缩方式
 
      (see accompanying documentation for algorithm
      descriptions)

      0 - The file is stored (no compression)
      1 - The file is Shrunk
      2 - The file is Reduced with compression factor 1
      3 - The file is Reduced with compression factor 2
      4 - The file is Reduced with compression factor 3
      5 - The file is Reduced with compression factor 4
      6 - The file is Imploded
      7 - Reserved for Tokenizing compression algorithm
      8 - The file is Deflated
      9 - Enhanced Deflating using Deflate64(tm)
     10 - PKWARE Data Compression Library Imploding
     11 - Reserved by PKWARE
     12 - File is compressed using BZIP2 algorithm
 
file data 文件数据
 
记录了相应压缩文件的数据
 
data descriptor 数据描述符
 
用于标识该文件压缩结束，该结构只有在相应的local file header中通用标记字段的第３bit设为１时才会出现，紧接在压缩文件源数据后。这个数据描述符只用在不能对输出的 ZIP 文件进行检索时使用。例如：在一个不能检索的驱动器（如：磁带机上）上的 ZIP 文件中。如果是磁盘上的ZIP文件一般没有这个数据描述符。
 
Offset
Bytes
Description
译
0
4
crc-32
CRC-32校验码
4
4
compressed size
压缩后的大小
8
4
uncompressed size
未压缩的大小
## Central directory 核心目录
 记录了压缩文件的目录信息，在这个数据区中每一条纪录对应在压缩源文件数据区中的一条数据。
 
核心目录结构如下：
 
Offset
Bytes
Description
译
0
4
Central directory file header signature = 0x02014b50
核心目录文件header标识=（0x02014b50）
4
2
Version made by
压缩所用的pkware版本
6
2
Version needed to extract (minimum)
解压所需pkware的最低版本
8
2
General purpose bit flag
通用位标记
10
2
Compression method
压缩方法
12
2
File last modification time
文件最后修改时间
14
2
File last modification date
文件最后修改日期
16
4
CRC-32
CRC-32校验码
20
4
Compressed size
压缩后的大小
24
4
Uncompressed size
未压缩的大小
28
2
File name length (n)
文件名长度
30
2
Extra field length (m)
扩展域长度
32
2
File comment length (k)
文件注释长度
34
2
Disk number where file starts
文件开始位置的磁盘编号
36
2
Internal file attributes
内部文件属性
38
4
External file attributes
外部文件属性
42
4
relative offset of local header
本地文件头的相对位移
46
n
File name
目录文件名
46+n
m
Extra field
扩展域
46+n+m
k
File comment
文件注释内容
End of central directory record(EOCD) 目录结束标识
 
目录结束标识存在于整个归档包的结尾，用于标记压缩的目录数据的结束。每个压缩文件必须有且只有一个EOCD记录。
 
Offset
Bytes
Description
译
0
4
End of central directory signature = 0x06054b50
核心目录结束标记（0x06054b50）
4
2
Number of this disk
当前磁盘编号
6
2
number of the disk with the start of the central directory
核心目录开始位置的磁盘编号
8
2
total number of entries in the central directory on this disk
该磁盘上所记录的核心目录数量
10
2
total number of entries in the central directory
核心目录结构总数
12
4
Size of central directory (bytes)
核心目录的大小
16
4
offset of start of central directory with respect to the starting disk number
核心目录开始位置相对于archive开始的位移
20
2
.ZIP file comment length(n)
注释长度
22
n
.ZIP Comment
注释内容
样例分析
 
这里只考虑最简单的一种场景，只包括一个文本文件的压缩文件。
 新建一个名为123.txt的文本文件，内容为123456
 将123.txt压缩为123.zip
 
使用winhex打开123.zip（注：winhex是以小端模式展示数据的）
 
 
Offset
Bytes
Contents
Descriptor
LOCAL FILE HEADER
00000000
4
50 4B 03 04
文件头标识(0x04034b50)
00000004
2
0A 00
解压文件所需 pkware最低版本
00000006
2
00 00
通用比特标志位
00000008
2
08 00
压缩方式
0000000A
2
E1 5D
文件最后修改时间
0000000C
2
CC 48
文件最后修改日期
0000000E
4
61 D3 72 09
crc-32校验码
00000012
4
08 00 00 00
压缩后的大小
00000016
4
06 00 00 00
未压缩的大小
0000001A
2
07 00
文件名长度
0000001C
2
00 00
扩展区长度
0000001E
6
31 32 33 2E 74 78 74
文件名 123.txt
FILE DATA
00000025
8
33 34 32 36 31 35 03 00
压缩文件数据，此处就是压缩文本文件123.txt压缩后的数据
Central Directory Header
0000002D
4
50 4B 01 02
核心目录文件header标识=（0x02014b50）
00000031
2
0A 00
压缩所用的pkware版本
00000033
2
0A 00
解压所需pkware的最低版本
00000035
2
00 00
通用位标记
00000037
2
08 00
压缩方法
00000039
2
E1 5D
文件最后修改时间
0000003B
2
CC 48
文件最后修改日期
0000003D
4
61 D3 72 09
CRC-32校验码
00000041
4
08 00 00 00
压缩后的大小
00000045
4
06 00 00 00
未压缩的大小
00000049
2
07 00
文件名长度
0000004B
2
00 00
扩展域长度
0000004D
2
00 00
文件注释长度
0000004F
2
00 00
文件开始位置的磁盘编号
00000051
2
00 00
内部文件属性
00000053
4
20 00 00 00
外部文件属性
00000057
4
00 00 00 00
本地文件header的相对位移
0000005B
7
31 32 33 2E 74 78 74
目录文件名
End of central directory record
00000062
4
50 4B 05 06
核心目录结束标记（0x06054b50）
00000066
2
00 00
当前磁盘编号
00000068
2
00 00
核心目录开始位置的磁盘编号
0000006A
2
01 00
该磁盘上所记录的核心目录数量
0000006C
2
01 00
核心目录结构总数
0000006E
4
35 00 00 00
核心目录的大小
00000072
4
2D 00 00 00
核心目录开始位置相对于archive开始的位移
00000076
2
00 00
注释长度
参考文献
 
[1] 官方文档 - APPNOTE-6.2.0.txt
 [1] zip文件格式分析 - A Flying Bird - 博客频道 - CSDN.NET
 [2] zip文件格式说明_elly_新浪博客
 [3] ZIP文件格式详解 - sony303的专栏 - 博客频道 - CSDN.NET
 [4] ZIP文件格式详解 - 董盼山的专栏 - 博客频道 - CSDN.NET
 [5] zip格式分析 - lianghongge的专栏 - 博客频道 - CSDN.NET