java 压缩文件 解压缩文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.zip.Adler32;
import java.util.zip.CheckedInputStream;
import java.util.zip.CheckedOutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import org.apache.commons.lang.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class ZipUtils {
	public static final int BUFFER = 2048;
	private static final Logger logger = LoggerFactory.getLogger(ZipUtils.class);

	public static void main(String[] args) throws IOException {
		zipFile("F:\\123.txt", "F:\\123.zip");
		String file="xx";
	}

	// public static void zipStr(String str, String zipFile) throws IOException {
	// Validate.notEmpty(str, "srcFile is empty!");
	// Validate.notEmpty(zipFile, "zipFile is empty!");
	// ZipOutputStream zos = null;
	// try {
	// FileOutputStream dest = new FileOutputStream(zipFile);
	// CheckedOutputStream checksum = new CheckedOutputStream(dest, new Adler32());
	// zos = new ZipOutputStream(checksum);
	//			
	// zipFile(srcFile, zos);
	// } finally {
	// if (zos != null)
	// zos.close();
	// }
	// }
	public static void zipFile(String srcFile, String zipFile) throws IOException {
		Validate.notEmpty(srcFile, "srcFile is empty!");
		Validate.notEmpty(zipFile, "zipFile is empty!");
		ZipOutputStream zos = null;
		try {
			FileOutputStream dest = new FileOutputStream(zipFile);
			CheckedOutputStream checksum = new CheckedOutputStream(dest, new Adler32());
			zos = new ZipOutputStream(checksum);
			zipFile(srcFile, zos);
		} finally {
			if (zos != null)
				zos.close();
		}
	}

	public static void zipFile(String srcFile, ZipOutputStream zos) throws IOException {
		Validate.notEmpty(srcFile, "srcFile is empty!");
		Validate.notNull(zos, "zos is null!");
		File file = new File(srcFile);
		FileInputStream fis = new FileInputStream(file);
		try {
			zipFile(file.getName(), fis, zos);
		} finally {
			fis.close();
		}
	}

	public static void zipFile(String isName, InputStream is, ZipOutputStream zos) throws IOException {
		Validate.notEmpty(isName, "isName is empty!");
		Validate.notNull(is, "InputStream is null!");
		Validate.notNull(zos, "zos is null!");
		BufferedInputStream origin = null;
		byte[] data = new byte[2048];
		try {
			origin = new BufferedInputStream(is, 2048);
			ZipEntry entry = new ZipEntry(isName);
			zos.putNextEntry(entry);
			int count;
			while ((count = origin.read(data, 0, 2048)) != -1) {
				// int count;
				zos.write(data, 0, count);
			}
		} finally {
			if (origin != null) {
				origin.close();
				origin = null;
			}
		}
	}

	public static void zipDirectory(String srcDir, boolean recursion, String zipFile) throws IOException {
		zipDirectory(srcDir, null, recursion, zipFile);
	}

	public static void zipDirectory(String srcDir, boolean recursion, ZipOutputStream zos) throws IOException {
		zipDirectory(srcDir, null, recursion, zos);
	}

	public static void zipDirectory(String srcDir, FileFilter filter, boolean recursion, String zipFile) throws IOException {
		Validate.notEmpty(srcDir, "srcDir is empty!");
		Validate.notEmpty(zipFile, "zipFile is empty!");
		ZipOutputStream zos = null;
		try {
			FileOutputStream dest = new FileOutputStream(zipFile);
			CheckedOutputStream checksum = new CheckedOutputStream(dest, new Adler32());
			zos = new ZipOutputStream(checksum);
			zipDirectory(srcDir, filter, recursion, zos);
		} finally {
			if (zos != null)
				zos.close();
		}
	}

	public static void tarDirectory(String srcDir, FileFilter filter, boolean recursion, String zipFile) throws IOException {
		Validate.notEmpty(srcDir, "srcDir is empty!");
		Validate.notEmpty(zipFile, "zipFile is empty!");
		ZipOutputStream zos = null;
		try {
			FileOutputStream dest = new FileOutputStream(zipFile);
			CheckedOutputStream checksum = new CheckedOutputStream(dest, new Adler32());
			zos = new ZipOutputStream(checksum);
			zos.setLevel(0);
			zipDirectory(srcDir, filter, recursion, zos);
		} finally {
			if (zos != null)
				zos.close();
		}
	}

	public static void zipDirectory(String srcDir, FileFilter filter, boolean recursion, ZipOutputStream zos) throws IOException {
		Validate.notEmpty(srcDir, "srcDir is empty!");
		Validate.notNull(zos, "zos is null!");
		File dirFile = new File(srcDir);
		if (recursion) {
			zipDirectory(dirFile, filter, dirFile.getCanonicalFile().getName(), zos);
		} else
			zipDirectory(dirFile, filter, null, zos);
	}

	protected static void zipDirectory(File srcDir, FileFilter filter, String dirName, ZipOutputStream zos) throws IOException {
		BufferedInputStream origin = null;

		byte[] data = new byte[2048];

		File[] files = (File[]) null;
		if (filter == null)
			files = srcDir.listFiles();
		else {
			files = srcDir.listFiles(filter);
		}
		String entryName = null;
		for (File f : files) {
			if (f.isDirectory()) {
				if ((dirName != null) && (dirName.length() > 0)) {
					entryName = dirName + '/' + f.getName();
					zipDirectory(f, filter, entryName, zos);
				}
			} else
				try {
					entryName = f.getName();
					if (dirName != null) {
						entryName = dirName + '/' + f.getName();
					}
					FileInputStream fi = new FileInputStream(f);
					origin = new BufferedInputStream(fi, 2048);
					ZipEntry entry = new ZipEntry(entryName);
					zos.putNextEntry(entry);
					int count;
					while ((count = origin.read(data, 0, 2048)) != -1) {
						// int count;
						zos.write(data, 0, count);
					}
				} catch (IOException e) {
					logger.warn(f.getCanonicalPath() + "<--->" + e.getMessage());
				} finally {
					if (origin != null) {
						origin.close();
						origin = null;
					}
				}
		}
	}

	public static void unzipFile(String zipFile, String dstFile, boolean overwrite) throws IOException {
		Validate.notEmpty(zipFile, "zipFile is empty!");
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(zipFile);
			unzipFile(fis, dstFile, overwrite);
		} finally {
			if (fis != null)
				fis.close();
		}
	}

	public static void unzipFile(InputStream zipIs, String dstFile, boolean overwrite) throws IOException {
		Validate.notNull(zipIs, "zipIs is null!");
		Validate.notEmpty(dstFile, "dstFile is empty!");
		ZipInputStream zis = null;
		BufferedOutputStream dest = null;
		try {
			CheckedInputStream checksum = new CheckedInputStream(zipIs, new Adler32());
			zis = new ZipInputStream(checksum);
			ZipEntry zipEntry = zis.getNextEntry();
			byte[] data = new byte[2048];
			File file = new File(dstFile);
			if ((file.exists()) && (!overwrite))
				return;
			if (file.isDirectory()) {
				if (!file.exists()) {
					file.mkdirs();
				}
				file = new File(dstFile, zipEntry.getName());
			}
			File parent = file.getParentFile();
			if (!parent.exists()) {
				parent.mkdirs();
			}

			FileOutputStream fos = new FileOutputStream(file);
			dest = new BufferedOutputStream(fos, 2048);
			int count;
			while ((count = zis.read(data, 0, 2048)) != -1) {
				// int count;
				dest.write(data, 0, count);
			}
			dest.flush();
		} finally {
			if (dest != null) {
				dest.close();
			}
			if (zis != null)
				zis.close();
		}
		if (dest != null) {
			dest.close();
		}
		if (zis != null)
			zis.close();
	}

	public static void unzipDirectory(String zipFile, String dstDirectory, boolean overwrite) throws IOException {
		Validate.notEmpty(zipFile, "zipFile is empty!");
		Validate.notEmpty(dstDirectory, "dstDirectory is empty!");
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(zipFile);
			unzipDirectory(fis, dstDirectory, overwrite);
		} finally {
			if (fis != null)
				fis.close();
		}
	}

	public static void unzipDirectory(InputStream is, String dstDirectory, boolean overwrite) throws IOException {
		Validate.notNull(is, "InputStream is empty!");
		Validate.notEmpty(dstDirectory, "dstDirectory is empty!");
		ZipInputStream zis = null;
		try {
			CheckedInputStream checksum = new CheckedInputStream(is, new Adler32());
			zis = new ZipInputStream(checksum);
			unzipDirectory(zis, dstDirectory, overwrite);
		} finally {
			if (zis != null)
				zis.close();
		}
	}

	protected static void unzipDirectory(ZipInputStream zis, String dstDirectory, boolean overwrite) throws IOException {
		BufferedOutputStream dest = null;
		byte[] data = new byte[2048];
		File dirFile = new File(dstDirectory);
		if (!dirFile.exists())
			dirFile.mkdirs();
		ZipEntry entry;
		while ((entry = zis.getNextEntry()) != null) {
			// ZipEntry entry;
			File f = new File(dstDirectory, entry.getName());
			if (entry.isDirectory()) {
				if ((f.exists()) && (!overwrite))
					continue;
				f.mkdirs();
			} else {
				FileOutputStream fos = null;
				try {
					File parent = f.getParentFile();
					if (!parent.exists()) {
						parent.mkdirs();
					}
					if ((f.exists()) && (!overwrite)) {
						int count;
						if (dest != null) {
							dest.close();
							dest = null;
						}
						if (fos == null)
							continue;
						fos.close();

						continue;
					}
					fos = new FileOutputStream(f);
					dest = new BufferedOutputStream(fos, 2048);
					int count;
					while ((count = zis.read(data, 0, 2048)) != -1) {
						// int count;
						dest.write(data, 0, count);
					}
					dest.flush();
				} finally {
					if (dest != null) {
						dest.close();
						dest = null;
					}
					if (fos != null)
						fos.close();
				}
				int count;
				if (dest != null) {
					dest.close();
					dest = null;
				}
				if (fos != null)
					fos.close();
			}
		}
	}

	public static byte[] zipObject(Serializable object) {
		byte[] data = (byte[]) null;
		try {
			ByteArrayOutputStream o = new ByteArrayOutputStream();
			GZIPOutputStream gzout = new GZIPOutputStream(o);
			ObjectOutputStream out = new ObjectOutputStream(gzout);
			out.writeObject(object);
			out.flush();
			out.close();
			gzout.close();
			data = o.toByteArray();
			o.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return data;
	}

	public static Serializable unzipObject(byte[] data) {
		Serializable object = null;
		try {
			ByteArrayInputStream i = new ByteArrayInputStream(data);
			GZIPInputStream gzin = new GZIPInputStream(i);
			ObjectInputStream in = new ObjectInputStream(gzin);
			object = (Serializable) in.readObject();
			i.close();
			gzin.close();
			in.close();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return object;
	}
}