java使用java.util.zip处理ZIP压缩文件

 

在java后端开发中，有需要处理压缩文件的场景，其实Java已经有自带的处理压缩文件的工具类，我们都知道输入流和输出流，其实还有压缩流（即：ZipOutPutStream）是专门对文件进行压缩的一个类，包名为：java.util.zip。java.util.zip在jdk的api中是这样介绍的：

• 该类实现了以ZIP文件格式写入文件的输出流过滤器。 包括对压缩和未压缩条目的支持。

• 废话不多说，上代码。

• import java.io.*;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipOutputStream;
   
  /**
   * ZipUtils
   * 文件压缩工具类
   */
   
  public class ZipUtils {
   
      private static final int BUFFER_SIZE = 2 * 1024;
   
      /**
       * 方法1--根据文件夹路径压缩成ZIP 
       * @param srcDir 压缩文件夹路径
       * @param out 压缩文件输出流
       * @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构; false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
       * @throws RuntimeException 压缩失败会抛出运行时异常
       */
      public static void toZip(String srcDir, OutputStream out, boolean KeepDirStructure) throws RuntimeException {
   
          long start = System.currentTimeMillis();
          ZipOutputStream zos = null;
          try {
              zos = new ZipOutputStream(out);
              File sourceFile = new File(srcDir);
              compress(sourceFile, zos, sourceFile.getName(), KeepDirStructure);
              long end = System.currentTimeMillis();
              log.debug("压缩完成，耗时：" + (end - start) + " ms");
          } catch (Exception e) {
              throw new RuntimeException("zip error from ZipUtils", e);
          } finally {
              if (zos != null) {
                  try {
                      zos.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
   
      }
   
      /**
       * 方法2--根据需要压缩的文件列表压缩成ZIP 
       * @param srcFiles 需要压缩的文件列表
       * @param out 压缩文件输出流
       * @throws RuntimeException 压缩失败会抛出运行时异常
       */
      public static void toZip(List<File> srcFiles, OutputStream out) throws RuntimeException {
          long start = System.currentTimeMillis();
          ZipOutputStream zos = null;
          try {
              zos = new ZipOutputStream(out);
              for (File srcFile : srcFiles) {
                  byte[] buf = new byte[BUFFER_SIZE];
                  zos.putNextEntry(new ZipEntry(srcFile.getName()));
                  int len;
                  FileInputStream in = new FileInputStream(srcFile);
                  while ((len = in.read(buf)) != -1) {
                      zos.write(buf, 0, len);
                  }
                  zos.closeEntry();
                  in.close();
              }
              long end = System.currentTimeMillis();
              System.out.println("压缩完成，耗时：" + (end - start) + " ms");
          } catch (Exception e) {
              throw new RuntimeException("zip error from ZipUtils", e);
          } finally {
              if (zos != null) {
                  try {
                      zos.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
   
      /**
       * 递归压缩方法
       * @param sourceFile 源文件
       * @param zos zip输出流
       * @param name 压缩后的名称
       * @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构; false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
       * @throws Exception
       */
      private static void compress(File sourceFile, ZipOutputStream zos, String name, boolean KeepDirStructure)
          throws Exception {
          byte[] buf = new byte[BUFFER_SIZE];
          if (sourceFile.isFile()) {
              // 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
              zos.putNextEntry(new ZipEntry(name));
              // copy文件到zip输出流中
              int len;
              FileInputStream in = new FileInputStream(sourceFile);
              while ((len = in.read(buf)) != -1) {
                  zos.write(buf, 0, len);
              }
              // Complete the entry
              zos.closeEntry();
              in.close();
          } else {
              File[] listFiles = sourceFile.listFiles();
              if (listFiles == null || listFiles.length == 0) {
                  // 需要保留原来的文件结构时,需要对空文件夹进行处理
                  if (KeepDirStructure) {
                      // 空文件夹的处理
                      zos.putNextEntry(new ZipEntry(name + "/"));
                      // 没有文件，不需要文件的copy
                      zos.closeEntry();
                  }
   
              } else {
                  for (File file : listFiles) {
                      // 判断是否需要保留原来的文件结构
                      if (KeepDirStructure) {
                          // 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
                          // 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
                          compress(file, zos, name + "/" + file.getName(), KeepDirStructure);
                      } else {
                          compress(file, zos, file.getName(), KeepDirStructure);
                      }
   
                  }
              }
          }
      }
  
  
     
     
       /**
       * 解压zip压缩包方法
       * @param srcPath 压缩文件路径
       * @param destPat 解压后保存路径
       * @throws Exception
       */
      public static void decompress(String srcPath, String destPath) throws Exception {
          File file = new File(srcPath);
          if (!file.exists()) {
              throw new RuntimeException(srcPath + "文件不存在");
          }
   
          ZipFile zf = new ZipFile(file);
          Enumeration entries = zf.entries();
          ZipEntry entry;
          while (entries.hasMoreElements()) {
              entry = (ZipEntry) entries.nextElement();
              //非文件
              if (entry.isDirectory()) {
                  String dirPath = destPath + File.separator + entry.getName();
                  File dir = new File(dirPath);
                  dir.mkdirs();
              } else {
                  //文件
                  File f = new File(destPath + File.separator + entry.getName());
                  if (!f.exists()) {
                      f.createNewFile();
                  }
   
                  // 文件数据写入文件
                  InputStream is = zf.getInputStream(entry);
                  FileOutputStream fos = new FileOutputStream(f);
   
                  int count;
                  byte[] buf = new byte[1024 * 4];
                  while ((count = is.read(buf)) != -1) {
                      fos.write(buf, 0, count);
                  }
   
                  is.close();
                  fos.close();
              }
          }
      }
  
      public static void main(String[] args) throws Exception {
          /** 测试压缩方法1 */
          /*  FileOutputStream fos1 = new FileOutputStream(new File("D:\\test\\back.zip"));
          ZipUtils.toZip("D:\\test\\back", fos1, true);*/
   
          // 测试压缩方法2 /*
          List<File> fileList = new ArrayList<>();
          fileList.add(new File("D:\\test\\exp\\sms\\exp_dr_sms_102_00000001.data"));
          fileList.add(new File("D:\\test\\exp\\sms\\exp_dr_sms_102_00000002.data"));
          fileList.add(new File("D:\\test\\exp\\sms\\exp_dr_sms_102_00000003.data"));
          FileOutputStream fos2 = new FileOutputStream(new 
          File("D:\\test\\exp\\sms\\exp_dr_sms_102a.zip"));
          ZipUtils.toZip(fileList, fos2);
      }
  }