Java压缩与解压缩ZIP文件

客官°小女子只卖身不卖艺 2024-03-22 14:38 180阅读 0赞

文章目录

    • 前言
    • Java解压缩文件
    • 压缩和解压缩ZIP文件
    • 检验
    • 应用
    • 总结

前言

在现代计算机上，数据传输和存储越来越依赖于文件压缩技术。当我们需要发送大量数据时，压缩文件可以大大减少传输时间和网络带宽，而且压缩文件还可以帮助我们节省磁盘空间。在Java中提供了压缩和解压缩文件的功能，可以使用java.util.zip包中的类来实现。本篇将对如何使用 Java 实现单文多件压缩和解压缩进行总结。

文件压缩指的是将一个或多个文件通过压缩算法，将其存储为一个更小的文件，以便于存储和传输。压缩的原理是通过对文件的数据进行编码和压缩，使其占用更少的空间。压缩后的文件可以通过解压缩算法还原成原始的文件格式。在文件压缩过程中，常见的操作是将多个文件打包成一个压缩文件，例如zip、tar等格式。

Java解压缩文件

常见的文件压缩格式包括：

  • ZIP：最常见的压缩文件格式之一，可以存储一个或多个文件，并可在不同的操作系统中进行解压缩。
  • TAR：Linux系统中的常见文件压缩格式，通常用于打包多个文件，但不会进行压缩。
  • GZIP：常用的文件压缩格式，通常用于压缩单个文件，可以获得更高的压缩比。
  • BZIP2：高效的压缩算法，通常用于压缩文本文件和XML文件等。
  • JAR: Jar包对于Java开发同学来说肯定很熟悉，其也是一个压缩包

Java提供了多种用于压缩和解压缩文件的API，主要包括以下类和方法：

  • ZipOutputStream 和 ZipInputStream：用于创建和读取ZIP格式的压缩文件。
  • GZIPOutputStream 和 GZIPInputStream：用于创建和读取GZIP格式的压缩文件。
  • JarOutputStream 和 JarInputStream：用于创建和读取JAR格式的压缩文件。
  • DeflaterOutputStream 和 InflaterInputStream：用于创建和读取DEFLATE格式的压缩文件。
  • CheckedOutputStream 和 CheckedInputStream：用于在压缩和解压缩过程中计算文件的校验和。

压缩和解压缩ZIP文件

通过使用Java 自带的 java.util.zip 类库下的ZipOutputStream、ZipInputStream、ZipEntry实现文件的压缩和解压缩，其中ZipOutputStream用于创建ZIP压缩文件输出流输出ZIP压缩文件，ZipInputStream用于创建ZIP文件输入流读取ZIP文件用于解压缩而ZipEntry对应ZIP压缩包中的每个被压缩对象；

  • 生成ZIP文件

    压缩单个文件或者单个文件夹方法，代码如下:

    1. /**
    2.  * 压缩文件(支持单个文件和单个文件夹)
    3.  * @param sourceFile 被压缩文件/文件夹
    4.  * @param zipFile Zip文件
    5.  */
    6. public static void zipCompress(File sourceFile, File zipFile) {
    8.     try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) {
    10.         // 设置压缩方法
    11.         zos.setMethod(ZipOutputStream.DEFLATED);
    12.         zos.setLevel(Deflater.BEST_COMPRESSION); // 默认为-1,压缩级别，1速度快，效率低，9 速度满，效率高
    13.         // zos.setLevel(Deflater.BEST_SPEED);
    14.         zos.setComment("zip文件说明");
    15.         // 处理文件夹
    16.         if (sourceFile.exists() && sourceFile.isDirectory() && Objects.nonNull(sourceFile.listFiles())){
    18.             Arrays.stream(Objects.requireNonNull(sourceFile.listFiles())).forEach(file -> {
    20.                 addZipFile(file, zos);
    21.             });
    22.         }else{
    24.             addZipFile(sourceFile, zos);
    25.         }
    26.     } catch (IOException e) {
    28.         e.printStackTrace();
    29.     }
    30. }

    为了支持读取单个文件夹进行压缩，增加一个向ZipOutputStream中添加ZipEntry的方法，代码如下：

    1. /**
    2.  * 向ZIP中添加文件
    3.  * @param file 源文件
    4.  * @param zos zip输出流
    5.  */
    6. private static void addZipFile(File file, ZipOutputStream zos){
    8.     if (!file.exists() || file.isDirectory()){
    10.         throw new RuntimeException("文件不存在或该文件为文件夹，请检查");
    11.     }
    12.     try {
    14.         // 读入文件
    15.         FileInputStream fis = new FileInputStream(file);
    16.         // 创建压缩对象并设置一些属性
    17.         ZipEntry entry = new ZipEntry(file.getName());
    18.         entry.setMethod(ZipEntry.DEFLATED); // 压缩方法默认为DEFLATED
    19.         // entry.setMethod(ZipEntry.STORED); // STORED（不压缩）。当使用STORED压缩方法时，需要设置未压缩的数据大小和CRC-32校验和，否则压缩和解压缩时会出现错误。
    20.         entry.setSize(file.length()); // 设置未压缩的数据大小，这里设置的是文件大小
    21.         // 计算 CRC-32 校验码
    22.         // byte[] data = Files.readAllBytes(file.toPath());
    23.         // CRC32 crc = new CRC32();
    24.         // crc.update(data);
    25.         // entry.setCrc(crc.getValue()); // 设置CRC-32校验和，用于保证压缩后的数据完整性，尽量别手动设置，可以通过CRC-32计算
    26.         entry.setCompressedSize(file.length()); // 设置压缩后的数据大小，这里设置的是使用DEFLATED方法压缩后的数据大小
    27.         entry.setExtra(new byte[]{
    28.       }); // 设置额外的数据，这里设置为空
    29.         entry.setComment("file comment"); // 设置ZipEntry的注释，即文件说明
    30.         entry.setCreationTime(FileTime.from(Instant.now())); // 设置文件的创建时间
    31.         entry.setLastAccessTime(FileTime.from(Instant.now())); // 设置文件的最后访问时间
    32.         entry.setLastModifiedTime(FileTime.from(Instant.now())); // 设置文件的最后修改时间。
    33.         // 向ZIP输出流中添加一个ZIP实体，构造方法中的name参数指定文件在ZIP包中的文件名
    34.         zos.putNextEntry(entry);
    35.         // 向ZIP实体中写入内容
    36.         byte[] buf = new byte[1024];
    37.         int len;
    38.         while ((len = fis.read(buf)) > 0) {
    40.             zos.write(buf, 0, len);
    41.         }
    42.         // 关闭ZipEntry
    43.         zos.closeEntry();
    44.     } catch (IOException e) {
    46.         e.printStackTrace();
    47.     }
    48. }

    注意:

    涉及到文件IO流，如果没有使用try with source 的语法，一定要记得关闭输入输出流;

    使用Java.util.zip下的工具类压缩成ZIP不支持设置ZIP密码且每种模式下生成的ZIP文件大小大于等于原文件/文件夹;

    当使用STORED压缩方法时，需要设置未压缩的数据大小和CRC-32校验和,该值需要借助CRC-32计算非常的麻烦，不设置此值会抛出异常;

    对于压缩，可以使用 ZipOutputStream 的 putNextEntry 方法逐个添加文件，避免将所有文件一次性读入内存;

    可以设置缓冲区大小，例如对于文件的读取和写入，可以设置缓冲区大小为 4KB 或者 8KB，减少内存的占用;

    对于解压缩，可以使用 ZipInputStream 的 getNextEntry 方法逐个读取文件，避免将所有文件一次性读入内存；

  • 解压缩ZIP文件

    将ZIP文件解压缩支持生成文件夹，代码如下:

    1. /**
    2.  * 解压缩ZIP文件
    3.  * @param zipFile ZIP文件
    4.  * @param destDir 目标路径
    5.  */
    6. public static void zipDecompress(File zipFile, File destDir) {
    8.     byte[] buffer = new byte[1024];
    9.     try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile))) {
    11.         ZipEntry entry = zis.getNextEntry();
    12.         while (entry != null) {
    14.             File file = new File(destDir, entry.getName());
    15.             if (entry.isDirectory()) {
    17.                 file.mkdirs();
    18.             } else {
    20.                 File parent = file.getParentFile();
    21.                 if (!parent.exists()) {
    23.                     parent.mkdirs();
    24.                 }
    25.                 try (FileOutputStream fos = new FileOutputStream(file)) {
    27.                     int len;
    28.                     while ((len = zis.read(buffer)) > 0) {
    30.                         fos.write(buffer, 0, len);
    31.                     }
    32.                 }
    33.             }
    34.             entry = zis.getNextEntry();
    35.         }
    36.     } catch (IOException e) {
    38.         e.printStackTrace();
    39.     }
    40. }

  • 如何避免压缩文件中的注入攻击？

    压缩文件中的路径名和文件名可以被精心构造的攻击者利用，从而使得解压缩的过程中可能会导致路径遍历、文件覆盖等问题，进而导致安全问题。为了避免这些安全问题，可以进行如下处理：

    • 限制压缩文件中的路径名和文件名的长度，以及字符集，可以采用白名单机制对输入进行限制；
    • 对于解压缩的路径名和文件名，不要使用压缩文件中的路径名和文件名，而是在解压缩时自行构造一个路径名和文件名；
    • 对于不可信任的压缩文件，最好在安全的环境下解压缩，例如在沙箱或虚拟机中进行操作。

检验

主要测试使用上述代码压缩单文件和解压缩单文件能否成功以后测量单个文件的处理耗时，同时测试单文件夹多文件压缩和解压缩能否成功以及处理耗时，单元测试代码如下：

  1. @Test
  2. void testJavaUtilZip(){
  3.     // 测试压缩和解压缩单文件ZIP
  4.     // 被压缩的MP4单文件，大小112.5MB
  5.     File inputFile = new File("/Users/zlc/Documents/own/images/GPT-4 Developer Livestream.mp4");
  6.     // ZIP文件路径
  7.     File zipFile = new File("/Users/zlc/Documents/own/mp4.zip");
  8.     // ZIP 解压缩路径
  9.     File unzipFile = new File("/Users/zlc/Documents/own/unzip");
  10.     long start = System.currentTimeMillis();
  11.     // 压缩文件
  12.     ZipFileUtil.zipCompress(inputFile, zipFile);
  13.     long end = System.currentTimeMillis();
  14.     System.out.println("ZIP-压缩单文件耗时:" + (end - start) + "毫秒");
  15.     start = System.currentTimeMillis();
  16.     ZipFileUtil.zipDecompress(zipFile, unzipFile);
  17.     end = System.currentTimeMillis();
  18.     System.out.println("ZIP-解压缩单文件耗时:" + (end - start) + "毫秒");
  19.     // 单文件夹多文件压缩和解压缩测试
  20.     // 文件夹大小2.42G
  21.     File inputFiles = new File("/Users/zlc/Documents/own/images");
  22.     File zipFiles = new File("/Users/zlc/Documents/own/imagesZip.zip");
  23.     File unzipFiles = new File("/Users/zlc/Documents/own/imagesUnzip");
  24.     start = System.currentTimeMillis();
  25.     // 压缩文件
  26.     ZipFileUtil.zipCompress(inputFiles, zipFiles);
  27.     end = System.currentTimeMillis();
  28.     System.out.println("ZIP - 多文件压缩耗时:" + (end - start) + "毫秒");
  29.     start = System.currentTimeMillis();
  30.     ZipFileUtil.zipDecompress(zipFiles, unzipFiles);
  31.     end = System.currentTimeMillis();
  32.     System.out.println("ZIP - 多文件解压缩耗时:" + (end - start) + "毫秒");
  33. }

测试结果如下：

  1. ZIP-压缩单文件耗时:5492毫秒
  2. ZIP-解压缩单文件耗时:1920毫秒
  3. ZIP - 多文件压缩耗时:136059毫秒
  4. ZIP - 多文件解压缩耗时:45739毫秒

同时测试了设置不同压缩等级的耗时比较，结果如下：

  1. // 不同压缩等级下的处理耗时 
  2. BEST_COMPRESSION 2.43G 文件夹耗时119801毫秒快两分钟了
  3. BEST_SPEED 2.43G 文件夹耗时112646毫秒 也没差多少，但确实快了

结论:

测试环境为MacOS 四核Intel Core i7，16G内存，处理将近2.5G大小的文件夹耗时接近两分钟，效率十分低下，在总文件大小不大的时候可以考虑使用JDK自带的压缩工具类。

应用

设计一个API，通过使用Hutool生成两个CSV文件和一个Excel文件，将这三个文件放入到ZIP压缩包中，当通过浏览器调用API时，下载ZIP压缩包。

同时在服务器上不生成CVS、EXCEL以及Zip文件而是直接通过HttpServletResponse将文件传送给客户端，避免服务器因过多生成这些文件导致服务硬盘不够用（PS：生成文件以后基本上不会有人管了，会随着时间的增加爆炸式增加，当然如果你需要留存建议生成本地文件存储到OSS中）,代码如下：

  1. /**
  2.  * 下载ZIP
  3.  * @param response HttpServletResponse 响应流
  4.  * @return zip file 
  5.  */
  6. @GetMapping(value = "/downloadZip")
  7. public String downloadZipFile(HttpServletResponse response) {
  10.     // 设置响应头
  11.     response.setContentType("application/octet-stream");
  12.     response.setHeader("Content-Disposition", "attachment; filename=download.zip");
  14.     try (ZipOutputStream outputStream = new ZipOutputStream(response.getOutputStream())) {
  17.         ExcelWriter writer = new ExcelWriter(true);
  18.         List<String> header = Arrays.asList("开始日期", "结束日期", "算法厂商", "期末资产总额", "累计成交金额",
  19.                 "期间委托笔数", "期间成交笔数", "期间撤单笔数");
  20.         writer.writeHeadRow(header);
  22.         List<List<String>> rows = new ArrayList<>();
  23.         rows.add(Arrays.asList("张三", "里斯", "男", "张三", "里斯", "男", "张三", "里斯"));
  24.         rows.add(Arrays.asList("李四", "王武", "女", "张三", "里斯", "男", "张三", "里斯"));
  25.         writer.write(rows);
  27.         writer.passRows(1);
  29.         List<String> header1 = Arrays.asList("日期", "资金账号", "算法母单编号", "委托编号", "交易所", "股票代码",
  30.                 "委托数量", "交易方向", "订单类型", "委托价格", "委托状态", "累计成交数量", "累计成交金额");
  31.         writer.writeHeadRow(header1);
  32.         writer.autoSizeColumn(writer.getCurrentRow());
  33.         List<List<String>> rows2 = new ArrayList<>();
  34.         rows2.add(Arrays.asList("张三", "里斯", "男", "张三", "里斯", "男", "张三", "里斯", "找大大", "赵打打", "炸", "茅台", "米线"));
  35.         rows2.add(Arrays.asList("李四", "王武", "女", "张三", "里斯", "男", "张三", "里斯", "找大大", "赵打打", "炸", "茅台", "米线"));
  36.         writer.write(rows2);
  37.         writer.autoSizeColumnAll();
  39.         ZipEntry entry = new ZipEntry("数据.xlsx");
  40.         outputStream.putNextEntry(entry);
  41.         writer.flush(outputStream);
  42.         writer.close();
  43.         outputStream.closeEntry();
  45.         ZipEntry entry1 = new ZipEntry("母单.csv");
  46.         outputStream.putNextEntry(entry1);
  47.         CsvWriter csvWriter1 = new CsvWriter(new OutputStreamWriter(outputStream));
  48.         String[] csvHead1 = {
  49.     "日期", "资金账号", "算法厂商", "算法", "算法母单编号", "交易所", "股票代码", "委托数量", "交易方向", "启动时间", "停止时间", "算法状态"};
  50.         csvWriter1.writeLine(csvHead1);
  51.         String[] csvData1 = {
  52.     "20230203", "98830901", "XX", "TWAP", "12984", "SH", "600000", "10000", "4", "102311", "112311", "1"};
  53.         String[] csvData2 = {
  54.     "20230203", "98830901", "XX", "TWAP", "12984", "SH", "600000", "10000", "4", "102311", "112311", "1"};
  55.         csvWriter1.writeLine(csvData1);
  56.         csvWriter1.writeLine(csvData2);
  58.         csvWriter1.flush();
  59.         outputStream.closeEntry();
  61.         ZipEntry entry2 = new ZipEntry("子单.csv");
  62.         outputStream.putNextEntry(entry2);
  63.         CsvWriter csvWriter2 = new CsvWriter(new OutputStreamWriter(outputStream));
  64.         String[] csvHead2 = {
  65.     "日期", "资金账号", "算法母单编号", "委托编号", "交易所", "股票代码", "委托数量", "交易方向", "订单类型", "委托价格", "委托状态", "累计成交数量", "累计成交金额"};
  66.         csvWriter2.writeLine(csvHead2);
  67.         String[] csvData3 = {
  68.     "20230203", "98830901", "12984", "ord1122", "SH", "600000", "1000", "4", "1", "7.23", "1", "800", "5600"};
  69.         String[] csvData4 = {
  70.     "20230203", "98830901", "12984", "ord1122", "SH", "600000", "1000", "4", "1", "7.23", "1", "800", "5600"};
  71.         csvWriter2.writeLine(csvData3);
  72.         csvWriter2.writeLine(csvData4);
  73.         csvWriter2.flush();
  74.         outputStream.closeEntry();
  75.         outputStream.finish();
  76.         return "success";
  77.     } catch (Exception e) {
  79.         return "faild";
  80.     }
  81. }

总结

Java 自带的 java.util.zip 类库是一个基础的压缩和解压缩类库，它提供了很基本的压缩和解压缩功能。在处理小型文件或数据时，java.util.zip 是一个可行的选择。不过，对于大型文件或数据的处理，效率可能会受到影响。相比之下，一些第三方的类库如 Apache Commons Compress、Zip4j 等提供了更为高级的压缩和解压缩功能，同时也提供了更好的性能。
本文首发于香菜喵，打开微信随时随地读，文章下方 ↓ ↓ ↓

发表评论

表情：
评论列表 （有 0 条评论，180人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java8 Zip 压缩与解压缩

    网上找过几个例子都有点小问题，还是谷歌找出来的靠谱。主要是增加了指定文件的功能，通过 Java8 的 Lambda 判断是否加入 ZIP 压缩，比较方便。函数表达式的签名是 F

    た 入场券た 入场券/ 0 赞/ 37 阅读

    相关 7zip解压缩文件

    最近要用到7zip来解压缩文件，由于这个需求平时用到的机会并不是很多，所以网上关于这方面的资料并不是很多，我找了很久，终于找到了一个解决方案。 一、首先需要下载一个7zSh

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 506 阅读