java实现zip解压缩工具，不依赖第三方类库

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
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;
public class ZipUtil {
/**
* 将可变长参数中的file全部压缩到名为zipFileName的压缩包中，压缩包存放在zipPath路径下
*
*
* @param zipPath
*
* 压缩包文件路径*
* @param zipFileName
*
* 压缩包文件名 *
* @param files
*
* 需要压缩的文件*
* @throws Exception
* @throws IOException
*/
public static void zip(String zipPath, String zipFileName, File... files) throws Exception, IOException {
List<File> fileList = new ArrayList<File>();
Collections.addAll(fileList, files);
zip(fileList, zipPath, zipFileName);
}
/**
* * 对文件或文件目录进行压缩 * *
*
* @param srcPath
*
* 要压缩的源文件路径。如果压缩一个文件，则为该文件的全路径；如果压缩一个目录，则为该目录的顶层目录路径 *
* @param zipPath
*
* 压缩文件保存的路径。注意：zipPath不能是srcPath路径下的子文件夹 *
* @param zipFileName
*
* 压缩文件名 *
* @throws Exception
*/
public static void zip(String srcPath, String zipPath, String zipFileName) throws Exception {
if (isEmpty(srcPath) || isEmpty(zipPath) || isEmpty(zipFileName)) {
throw new Exception("路径或文件名不能为空");
}
CheckedOutputStream cos = null;
ZipOutputStream zos = null;
try {
File srcFile = new File(srcPath);
// 判断压缩文件保存的路径是否为源文件路径的子文件夹，如果是，则抛出异常（防止无限递归压缩的发生）
if (srcFile.isDirectory() && zipPath.indexOf(srcPath) != -1) {
throw new Exception("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();
} finally {
closeQuietly(zos);
}
}
public static void zip(List<File> fileList, String zipPath, String zipFileName) throws Exception, IOException {
if (isEmpty(zipPath) || isEmpty(zipFileName)) {
throw new Exception("路径或文件名不能为空");
}
if (null == fileList || fileList.isEmpty()) {
throw new Exception("文件列表不能为空");
}
CheckedOutputStream cos = null;
ZipOutputStream zos = null;
try {
// 判断压缩文件保存的路径是否为源文件路径的子文件夹，如果是，则抛出异常（防止无限递归压缩的发生）
for (File srcFile : fileList) {
if (srcFile.isDirectory() && zipPath.indexOf(srcFile.getPath()) != -1) {
throw new Exception("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 srcPath;
for (File srcFile : fileList) {
srcPath = srcFile.getPath();
// 如果只是压缩一个文件，则需要截取该文件的父目录
String srcRootDir = srcPath;
/* * if (srcFile.isFile()) { */
int index = srcFile.getPath().lastIndexOf(File.separator);
if (index != -1) {
srcRootDir = srcPath.substring(0, index);
}
// 调用递归压缩方法进行目录或文件压缩
zip(srcRootDir, srcFile, zos);
}
zos.flush();
} finally {
closeQuietly(zos);
}
}
/**
* * 解压缩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 (isEmpty(zipFilePath) || isEmpty(unzipFilePath)) {
throw new Exception("源路径和目的路径均不能为空！");
}
File zipFile = new File(zipFilePath);
// 如果解压后的文件保存路径包含压缩文件的文件名，则追加该文件名到解压路径
if (includeZipFileName) {
String fileName = zipFile.getName();
if (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();
bis.close();
}
zip.close();
}
/**
* 递归压缩文件夹
*
* @param srcRootDir
*
* 压缩文件夹根目录 *
* @param file
*
* 当前递归压缩的文件或目录对象
*
* @param zos
*
* 压缩文件存储对象 *
* @throws IOException
*/
private static void zip(String srcRootDir, File file, ZipOutputStream zos) throws IOException {
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);
BufferedInputStream bis = null;
try {
bis = new BufferedInputStream(new FileInputStream(file));
zos.putNextEntry(entry);
while ((count = bis.read(data, 0, bufferLen)) != -1) {
zos.write(data, 0, count);
}
} finally {
closeQuietly(bis);
// 这个一直都要用不能关
// IOUtil.closeQuietly(zos);
}
}
// 如果是目录，则压缩整个目录
else {
// 压缩目录中的文件或子目录
File[] childFileList = file.listFiles();
if (null == childFileList) {
return;
}
for (File childFile : childFileList) {
zip(srcRootDir, childFile, zos);
}
}
}
public static boolean isEmpty(String str) {
return str == null || str.trim().length() < 1;
}
/**
* 判断字符串是否不是null且不是空字符串""
*/
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
private static void closeQuietly(Closeable Closeable) {
if (null != Closeable) {
try {
Closeable.close();
Closeable = null;
} catch (Exception e) {
}
}
}
public static void main(String[] args) {
try {
zip("D:", "abc.zip", new File("D:\abc.txt"), new File("D:\abcd.txt"));
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}

最后

以上就是平常芝麻为你收集整理的java实现zip解压缩工具，不依赖第三方类库的全部内容，希望文章能够帮你解决java实现zip解压缩工具，不依赖第三方类库所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。