使用java压缩文件成zip——三种方式压缩文件速度对比

文章目录
写在前面
使用Buffered缓冲流压缩
使用nio的FileChannel压缩
使用apache.commons包下的并行压缩方式压缩
写在前面
对于大文件批量压缩的问题，实际上是非常消耗时间的，怎么能提高压缩速度呢？
在这里提供了三种方式压缩文件，咱们对比一下哪一个压缩速度更快。

在这里提供了三个文件，压缩后的大小大概是1.1GB左右，咱们测试一下每一种压缩方式的压缩时间。

使用Buffered缓冲流压缩
    /**
     * zip文件压缩
     * @param inputFile 待压缩文件夹/文件名
     * @param outputFile 生成的压缩包名字
     */

    public static void ZipCompress(String inputFile, String outputFile) throws Exception {
        //创建zip输出流
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(outputFile));
        //创建缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(out);
        File input = new File(inputFile);
        compress(out, bos, input,null);
        bos.close();
        out.close();
    }
    /**
     * @param name 压缩文件名，可以写为null保持默认
     */
    //递归压缩
    public static void compress(ZipOutputStream out, BufferedOutputStream bos, File input, String name) throws IOException {
        if (name == null) {
            name = input.getName();
        }
        //如果路径为目录（文件夹）
        if (input.isDirectory()) {
            //取出文件夹中的文件（或子文件夹）
            File[] flist = input.listFiles();

            if (flist.length == 0)//如果文件夹为空，则只需在目的地zip文件中写入一个目录进入
            {
                out.putNextEntry(new ZipEntry(name + "/"));
            } else//如果文件夹不为空，则递归调用compress，文件夹中的每一个文件（或文件夹）进行压缩
            {
                for (int i = 0; i < flist.length; i++) {
                    compress(out, bos, flist[i], name + "/" + flist[i].getName());
                }
            }
        } else//如果不是目录（文件夹），即为文件，则先写入目录进入点，之后将文件写入zip文件中
        {
            out.putNextEntry(new ZipEntry(name));
            FileInputStream fos = new FileInputStream(input);
            BufferedInputStream bis = new BufferedInputStream(fos);
            int len;
            //将源文件写入到zip文件中
            byte[] buf = new byte[1024];
            while ((len = bis.read(buf)) != -1) {
                bos.write(buf,0,len);
            }
            bis.close();
            fos.close();
        }
    }
    public static void main(String[] args) {
        try {
            //压缩
            System.out.println("开始压缩");
            long date = new Date().getTime();
            ZipCompress("D:\\fileTest", "D:\\TestbyYTT.zip");
            System.out.println("压缩结束用时" + (new Date().getTime() - date));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

执行了三次，结果如下：
开始压缩
压缩结束用时46835

开始压缩
压缩结束用时48016

开始压缩
压缩结束用时47280
1
2
3
4
5
6
7
8
9
10
结论：平均就是47秒左右。

使用nio的FileChannel压缩
    /**
     * NIO方式压缩
     */
    public static File fileToZip(String sourceFilePath, String zipFilePath, String fileName) throws IOException {
        File sourceFile = new File(sourceFilePath);
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        ZipOutputStream zos = null;
        WritableByteChannel writableByteChannel = null;
        File zipFile = new File(zipFilePath + "/" + fileName);
        if (!sourceFile.exists()) {
            System.out.println("待压缩的文件目录：" + sourceFilePath + "不存在.");
        } else {
            try {
                if (zipFile.exists()) {
                    Files.delete(zipFile.toPath());
                }
                File[] sourceFiles = sourceFile.listFiles();
                if (null == sourceFiles || sourceFiles.length < 1) {
                    System.out.println("待压缩的文件目录：" + sourceFilePath + "里面不存在文件，无需压缩.");
                } else {
                    fos = new FileOutputStream(zipFile);
                    zos = new ZipOutputStream(new BufferedOutputStream(fos));
                    writableByteChannel = Channels.newChannel(zos) ;

                    for (File file : sourceFiles) {
                        //创建ZIP实体，并添加进压缩包
                        ZipEntry zipEntry = new ZipEntry(file.getName());
                        zos.putNextEntry(zipEntry);
                        //读取待压缩的文件并写进压缩包里
                        fis = new FileInputStream(file);
                        FileChannel fileChannel = fis.getChannel();
                        fileChannel.transferTo(0, file.length() -1,writableByteChannel);
                    }
                }
            } finally {
                //关闭流
                if (null != bis) {
                    bis.close();
                }
                if (fis != null) {
                    fis.close();
                }
                if (zos != null) {
                    zos.close();
                }
                if (fos != null) {
                    fos.close();
                }
                if (null != writableByteChannel) {
                    writableByteChannel.close();
                }
            }
        }
        return zipFile;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
执行了三次，结果如下：
开始压缩
压缩结束用时36929

开始压缩
压缩结束用时37783

开始压缩
压缩结束用时36246
1
2
3
4
5
6
7
8
9
结论：平均36秒左右。
注意！transferTo方法最大能读取2G的文件！

使用apache.commons包下的并行压缩方式压缩
   /**
     * @param sourceFilePath 需要压缩的目录
     * @param zipOutName 压缩后的文件名称
     **/
    public static void compressFileList(String sourceFilePath, String zipOutName) throws IOException, ExecutionException, InterruptedException {
        File sourceFile = new File(sourceFilePath);
        File[] sourceFiles = sourceFile.listFiles();
        ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("compressFileList-pool-").build();
        ExecutorService executor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20), factory);
        ParallelScatterZipCreator parallelScatterZipCreator = new ParallelScatterZipCreator(executor);
        OutputStream outputStream = new FileOutputStream(zipOutName);
        ZipArchiveOutputStream zipArchiveOutputStream = new ZipArchiveOutputStream(outputStream);
        zipArchiveOutputStream.setEncoding("UTF-8");
        for (File inFile : sourceFiles) {
            final InputStreamSupplier inputStreamSupplier = () -> {
                try {
                    return new FileInputStream(inFile);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    return new NullInputStream(0);
                }
            };
            ZipArchiveEntry zipArchiveEntry = new ZipArchiveEntry(inFile.getName());
            zipArchiveEntry.setMethod(ZipArchiveEntry.DEFLATED);
            zipArchiveEntry.setSize(inFile.length());
            zipArchiveEntry.setUnixMode(UnixStat.FILE_FLAG | 436);
            parallelScatterZipCreator.addArchiveEntry(zipArchiveEntry, inputStreamSupplier);
        }
        parallelScatterZipCreator.writeTo(zipArchiveOutputStream);
        zipArchiveOutputStream.close();
        outputStream.close();
        System.out.println("ParallelCompressUtil->ParallelCompressUtil-> info:{}"+ JSONObject.toJSONString(parallelScatterZipCreator.getStatisticsMessage()));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
执行了三次，结果如下：
开始压缩
ParallelCompressUtil->ParallelCompressUtil-> info:{}{"compressionElapsed":22642,"mergingElapsed":3802}
压缩结束用时27261

开始压缩
ParallelCompressUtil->ParallelCompressUtil-> info:{}{"compressionElapsed":21958,"mergingElapsed":3406}
压缩结束用时25524

开始压缩
ParallelCompressUtil->ParallelCompressUtil-> info:{}{"compressionElapsed":22076,"mergingElapsed":3668}
压缩结束用时25977
1
2
3
4
5
6
7
8
9
10
11
12
结论：平均26秒左右。
————————————————
版权声明：本文为CSDN博主「秃了也弱了。」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/A_art_xiang/article/details/125207480