Java打成各種壓縮包的方法詳細(xì)匯總

更新時間：2024年06月06日 09:40:34 作者：程序員阿誠

在工作過程中,需要將一個文件夾生成壓縮文件,然后提供給用戶下載,下面這篇文章主要給大家介紹了關(guān)于Java打成各種壓縮包的相關(guān)資料,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下

1.將指定目錄下的文件打包成 .zip

代碼示例：

import java.io.*;
import java.util.zip.*;

public class ZipFiles {
    public static void main(String[] args) {
        // 要壓縮的文件或文件夾
        String sourceFile = "path/to/your/source/file_or_folder";

        // 壓縮后的ZIP文件名
        String zipFileName = "output.zip";

        // 創(chuàng)建一個輸出流將數(shù)據(jù)寫入ZIP文件
        try (FileOutputStream fos = new FileOutputStream(zipFileName);
             ZipOutputStream zos = new ZipOutputStream(fos)) {

            // 調(diào)用遞歸方法壓縮文件或文件夾
            addToZipFile(sourceFile, sourceFile, zos);

            System.out.println("文件已成功打包成 " + zipFileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void addToZipFile(String path, String sourceFile, ZipOutputStream zos) throws IOException {
        File file = new File(sourceFile);

        // 如果是文件夾，則獲取其內(nèi)容并遞歸調(diào)用此方法
        if (file.isDirectory()) {
            String[] fileList = file.list();
            if (fileList != null) {
                for (String fileName : fileList) {
                    addToZipFile(path, sourceFile + File.separator + fileName, zos);
                }
            }
            return;
        }

        // 如果是文件，則將其添加到ZIP文件中
        try (FileInputStream fis = new FileInputStream(sourceFile)) {
            String entryName = sourceFile.substring(path.length() + 1); // 獲取ZIP中的條目名稱
            ZipEntry zipEntry = new ZipEntry(entryName);
            zos.putNextEntry(zipEntry);

            byte[] bytes = new byte[1024];
            int length;
            while ((length = fis.read(bytes)) >= 0) {
                zos.write(bytes, 0, length);
            }
        }
    }
}

將 path/to/your/source/file_or_folder 替換為要打包的文件或文件夾的路徑，然后運(yùn)行該代碼。它將創(chuàng)建一個名為 output.zip 的ZIP文件，其中包含指定路徑下的文件或文件夾。

2.將指定目錄下的文件打包成 .tar.gz

可以使用 Java 中的 java.util.zip 包來創(chuàng)建 .tar.gz 文件。盡管 Java 的標(biāo)準(zhǔn)庫沒有直接提供對 .tar 格式的支持，但你可以使用 TarArchiveOutputStream 以及 GzipCompressorOutputStream 來創(chuàng)建 tar.gz 歸檔文件。以下是一個示例：

import org.apache.commons.compress.archivers.tar.*;
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;

import java.io.*;

public class TarGzFiles {
    public static void main(String[] args) {
        // 要壓縮的文件或文件夾
        String sourceFile = "path/to/your/source/file_or_folder";

        // 壓縮后的tar.gz文件名
        String tarGzFileName = "output.tar.gz";

        try {
            FileOutputStream fos = new FileOutputStream(tarGzFileName);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            GzipCompressorOutputStream gzos = new GzipCompressorOutputStream(bos);
            TarArchiveOutputStream tarArchive = new TarArchiveOutputStream(gzos);

            File file = new File(sourceFile);
            addToTarArchive(file, tarArchive);

            tarArchive.finish();
            tarArchive.close();

            System.out.println("文件已成功打包成 " + tarGzFileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void addToTarArchive(File file, TarArchiveOutputStream tarArchive) throws IOException {
        String entryName = file.getName();
        TarArchiveEntry tarEntry = new TarArchiveEntry(file, entryName);

        tarArchive.putArchiveEntry(tarEntry);

        if (file.isFile()) {
            try (FileInputStream fis = new FileInputStream(file)) {
                byte[] buffer = new byte[1024];
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    tarArchive.write(buffer, 0, len);
                }
                tarArchive.closeArchiveEntry();
            }
        } else if (file.isDirectory()) {
            tarArchive.closeArchiveEntry();
            File[] children = file.listFiles();
            if (children != null) {
                for (File child : children) {
                    addToTarArchive(child, tarArchive);
                }
            }
        }
    }
}

在此示例中，使用了 Apache Commons Compress 庫，你可以在 Maven =添加以下依賴：

Maven：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-compress</artifactId>
    <version>1.21</version> <!-- 或者更高的版本 -->
</dependency>

確保將 path/to/your/source/file_or_folder 替換為要打包的文件或文件夾的實(shí)際路徑，然后運(yùn)行代碼以創(chuàng)建 output.tar.gz 文件。

3.將指定目錄下的文件打包成 .tar

Java的標(biāo)準(zhǔn)庫中并沒有直接支持創(chuàng)建.tar格式文件的類，但你可以使用Apache Commons Compress庫來完成這個任務(wù)。下面是一個示例代碼：

首先，確保你在項(xiàng)目中包含了Apache Commons Compress庫。如果使用Maven，可以在pom.xml文件中添加以下依賴項(xiàng)：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-compress</artifactId>
    <version>1.21</version> <!-- 或者更高的版本 -->
</dependency>

然后，使用以下代碼將文件打包成.tar文件：

import org.apache.commons.compress.archivers.tar.*;
import org.apache.commons.compress.utils.IOUtils;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class TarFiles {
    public static void main(String[] args) {
        // 要打包的文件或文件夾
        String sourceFile = "path/to/your/source/file_or_folder";

        // 打包后的tar文件名
        String tarFileName = "output.tar";

        try {
            FileOutputStream fos = new FileOutputStream(tarFileName);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            TarArchiveOutputStream tarArchive = new TarArchiveOutputStream(bos);

            addToTarArchive(sourceFile, tarArchive);

            tarArchive.finish();
            tarArchive.close();

            System.out.println("文件已成功打包成 " + tarFileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void addToTarArchive(String filePath, TarArchiveOutputStream tarArchive) throws IOException {
        Path sourcePath = Paths.get(filePath);
        String baseDir = sourcePath.getFileName().toString();

        Files.walk(sourcePath)
                .filter(path -> !Files.isDirectory(path))
                .forEach(path -> {
                    try {
                        String entryName = baseDir + File.separator + sourcePath.relativize(path).toString();
                        TarArchiveEntry tarEntry = new TarArchiveEntry(path.toFile(), entryName);
                        tarArchive.putArchiveEntry(tarEntry);

                        FileInputStream fis = new FileInputStream(path.toFile());
                        IOUtils.copy(fis, tarArchive);
                        fis.close();

                        tarArchive.closeArchiveEntry();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });
    }
}

在這個示例中，我們使用了Apache Commons Compress庫來創(chuàng)建.tar文件。確保將path/to/your/source/file_or_folder替換為你要打包的實(shí)際文件或文件夾的路徑，并運(yùn)行代碼來創(chuàng)建output.tar文件。

4.將指定目錄下的文件打包成 .rar

在Java中，壓縮成RAR格式的操作稍微有些復(fù)雜，因?yàn)镽AR格式是一種專有格式，并沒有Java標(biāo)準(zhǔn)庫提供直接支持。為了壓縮文件為RAR格式，你可以使用第三方庫，比如通過調(diào)用WinRAR或其他命令行工具來實(shí)現(xiàn)。

一種方法是使用Java的ProcessBuilder來運(yùn)行命令行來執(zhí)行WinRAR或其他RAR壓縮工具的命令。以下是一個簡單的示例，假設(shè)你已經(jīng)安裝了WinRAR并將其路徑添加到了系統(tǒng)的環(huán)境變量中：

import java.io.*;

public class RARFiles {
    public static void main(String[] args) {
        // 要壓縮的文件或文件夾
        String sourceFile = "path/to/your/source/file_or_folder";

        // 壓縮后的RAR文件名
        String rarFileName = "output.rar";

        try {
            // 構(gòu)建命令行
            String[] command = {"cmd", "/c", "rar", "a", "-r", rarFileName, sourceFile};

            // 創(chuàng)建進(jìn)程并執(zhí)行命令
            ProcessBuilder processBuilder = new ProcessBuilder(command);
            Process process = processBuilder.start();

            // 讀取進(jìn)程輸出（可選）
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }

            // 等待進(jìn)程執(zhí)行結(jié)束
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                System.out.println("文件已成功打包成 " + rarFileName);
            } else {
                System.out.println("打包過程中出現(xiàn)錯誤");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

請?zhí)鎿Q path/to/your/source/file_or_folder 為你要壓縮的文件或文件夾的路徑，并確保系統(tǒng)中已經(jīng)正確安裝和配置了WinRAR。

記住，這種方法需要系統(tǒng)中安裝有WinRAR并且路徑被正確添加到系統(tǒng)的環(huán)境變量中，且這個示例中的代碼并沒有對WinRAR命令返回的錯誤進(jìn)行詳細(xì)處理。

5.生成若干個txt并打包到zip中

代碼示例：

import java.io.*;
import java.util.zip.*;

public class GenerateTxtFilesAndZip {
    public static void main(String[] args) {
        String basePath = "path/to/your/directory"; // 更換為你想要保存文件的文件夾路徑
        int fileCount = 10; // 要生成的文件數(shù)量

        try {
            // 創(chuàng)建文件夾（如果不存在）
            File directory = new File(basePath);
            if (!directory.exists()) {
                directory.mkdirs();
            }

            // 生成txt文件并寫入內(nèi)容
            for (int i = 1; i <= fileCount; i++) {
                String fileName = "file" + i + ".txt";
                String filePath = basePath + File.separator + fileName;
                String fileContent = "This is the content of " + fileName;

                try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
                    writer.write(fileContent);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            // 打包成zip文件
            String zipFileName = "output.zip";
            byte[] buffer = new byte[1024];

            FileOutputStream fos = new FileOutputStream(zipFileName);
            ZipOutputStream zos = new ZipOutputStream(fos);

            File dir = new File(basePath);
            File[] files = dir.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.getName().endsWith(".txt")) {
                        FileInputStream fis = new FileInputStream(file);
                        zos.putNextEntry(new ZipEntry(file.getName()));

                        int length;
                        while ((length = fis.read(buffer)) > 0) {
                            zos.write(buffer, 0, length);
                        }

                        zos.closeEntry();
                        fis.close();
                    }
                }
            }

            zos.close();
            System.out.println("文件已成功打包成 " + zipFileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

請?zhí)鎿Qpath/to/your/directory為你想要保存生成文件的實(shí)際文件夾路徑。這段代碼會在指定路徑下生成10個.txt文件，并將它們打包成一個名為output.zip的ZIP文件。

附：Java實(shí)現(xiàn)zip、tar、tar.gz 打包壓縮解壓

package com.bj.drj;

import cn.hutool.core.lang.Console;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
import org.apache.commons.io.IOUtils;

import java.io.*;

/**
 * @ClassName PackAndCompressionUtils
 * @Description: 解壓壓縮文件
 * @Author drj
 * @Date 2021/9/18
 * @Version V1.0
 **/
public class PackAndCompressionUtils {


    private PackAndCompressionUtils() {
    }

    /**
     * 這個方法主要針對文件實(shí)現(xiàn)打包tar 也可以生成tar.gz 但是失去了gz 壓縮功能 只是現(xiàn)實(shí)了打包。
     *
     * @param filesPathArray 需要打包的文件
     * @param targetDirPath  生成tar 目錄
     * @return
     * @throws Exception
     */
    public static boolean tarPack(String[] filesPathArray, String targetDirPath) throws Exception {
        try (FileOutputStream fileOutputStream = new FileOutputStream(new File(targetDirPath));
             BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
             TarArchiveOutputStream tarArchiveOutputStream = new TarArchiveOutputStream(bufferedOutputStream)) {
            for (String filePath : filesPathArray) {
                try (FileInputStream fileInputStream = new FileInputStream(new File(filePath))) {
                    File file = new File(filePath);
                    TarArchiveEntry tae = new TarArchiveEntry(file, file.getName());
                    tarArchiveOutputStream.putArchiveEntry(tae);
                    IOUtils.copy(fileInputStream, tarArchiveOutputStream);
                    tarArchiveOutputStream.closeArchiveEntry();
                } catch (Exception e) {
                    Console.error(e, "異常信息：{}", filePath);
                }
            }
        } catch (Exception e) {
            Console.error(e, "異常信息：{}", filesPathArray);
        }
        return true;
    }

    /**
     * 解壓打包文件
     *
     * @param unPackFilePath
     * @param targetDirPath
     * @return
     * @throws Exception
     */
    public static boolean tarUnpack(String unPackFilePath, String targetDirPath) throws Exception {
        try (FileInputStream fileInputStream = new FileInputStream(new File(unPackFilePath));
             TarArchiveInputStream tarArchiveInputStream = new TarArchiveInputStream(fileInputStream)) {
            TarArchiveEntry tae = null;
            while ((tae = tarArchiveInputStream.getNextTarEntry()) != null) {
                String dir = targetDirPath + File.separator + tae.getName();
                try (FileOutputStream fileOutputStream = new FileOutputStream(new File(dir));
                     BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream)) {
                    IOUtils.copy(tarArchiveInputStream, bufferedOutputStream);
                } catch (Exception ex) {
                    Console.error(ex, "異常文件：{}", dir);
                }
            }
        } catch (Exception ex) {
            Console.error(ex, "異常文件：{}", unPackFilePath);
        }
        return true;
    }

    /**
     * gzip壓縮文件 后綴是.gz
     *
     * @param filesPathArray
     * @param targetDirPath
     * @return
     * @throws IOException
     */
    public static boolean gzipCompress(String[] filesPathArray, String targetDirPath) throws IOException {
        try (OutputStream outputStream = new FileOutputStream(new File(targetDirPath));
             GzipCompressorOutputStream gzipCompressorOutputStream = new GzipCompressorOutputStream(outputStream)) {
            for (String filePath : filesPathArray) {
                try (InputStream inputStream = new FileInputStream(new File(filePath));) {
                    TarArchiveOutputStream tarArchiveOutputStream = new TarArchiveOutputStream(gzipCompressorOutputStream);
                    File file = new File(filePath);
                    TarArchiveEntry archiveEntry = new TarArchiveEntry(file, file.getName());
                    tarArchiveOutputStream.putArchiveEntry(archiveEntry);
                    IOUtils.copy(inputStream, tarArchiveOutputStream);
                    tarArchiveOutputStream.closeArchiveEntry();
                } catch (Exception ex) {
                    Console.error(ex, "異常文件：{}", filePath);
                }
            }

        } catch (Exception ex) {
            Console.error(ex, "異常文件：{}", filesPathArray);
        }

        return true;
    }


    /**
     * 針對gz包 進(jìn)行解壓
     *
     * @param sourceDir
     * @param targetDirPath
     */
    public static boolean gzipDeCompress(String sourceDir, String targetDirPath) {
        try (
                FileInputStream fileInputStream = new FileInputStream(sourceDir);
                GzipCompressorInputStream gzipCompressorInputStream = new GzipCompressorInputStream(fileInputStream);
                TarArchiveInputStream tarArchiveInputStream = new TarArchiveInputStream(gzipCompressorInputStream);
        ) {
            TarArchiveEntry tarArchiveEntry = null;
            while ((tarArchiveEntry = tarArchiveInputStream.getNextTarEntry()) != null) {
                String dir = targetDirPath + File.separator + tarArchiveEntry.getName();
                try (FileOutputStream fileOutputStream = new FileOutputStream(new File(dir))) {
                    IOUtils.copy(tarArchiveInputStream, fileOutputStream);
                } catch (Exception ex) {
                    Console.error(ex, "異常文件路徑：{}", sourceDir);
                }
            }

        } catch (Exception ex) {
            Console.error(ex, "異常文件路徑：{}", sourceDir);
        }
        return true;
    }


    /**
     * 對文件進(jìn)行zip打包處理
     *
     * @param filesPathArray
     * @param targetDirPath
     * @return
     * @throws Exception
     */
    public static boolean zipCompress(String[] filesPathArray, String targetDirPath) throws Exception {
        try (FileOutputStream fileOutputStream = new FileOutputStream(new File(targetDirPath));
             ZipArchiveOutputStream zipArchiveOutputStream = new ZipArchiveOutputStream(fileOutputStream)) {

            for (String filePath : filesPathArray) {
                try (FileInputStream fileInputStream = new FileInputStream(new File(filePath))) {
                    File file = new File(filePath);
                    ZipArchiveEntry zae = new ZipArchiveEntry(file, file.getName());
                    zipArchiveOutputStream.putArchiveEntry(zae);
                    IOUtils.copy(fileInputStream, zipArchiveOutputStream);
                    zipArchiveOutputStream.closeArchiveEntry();
                } catch (Exception ex) {
                    Console.error(ex, "異常文件路徑：{}", filePath);
                }

            }
        } catch (Exception ex) {
            Console.error(ex, "異常文件路徑：{}", filesPathArray);
        }
        return true;
    }


    /**
     * 解壓zip 文件
     *
     * @param decompressFilePath
     * @param targetDirPath
     * @return
     * @throws Exception
     */
    public static boolean zipDecompress(String decompressFilePath, String targetDirPath) throws Exception {

        try (FileInputStream fileInputStream = new FileInputStream(new File(decompressFilePath));
             ZipArchiveInputStream zipArchiveInputStream = new ZipArchiveInputStream(fileInputStream)) {
            ZipArchiveEntry zae = null;
            while ((zae = zipArchiveInputStream.getNextZipEntry()) != null) {
                String dir = targetDirPath + File.separator + zae.getName();
                try (FileOutputStream fileOutputStream = new FileOutputStream(new File(dir))) {
                    IOUtils.copy(zipArchiveInputStream, fileOutputStream);
                } catch (Exception ex) {
                    Console.error(ex, "異常文件路徑：{}", dir);
                }
            }
        } catch (Exception ex) {
            Console.error(ex, "異常文件路徑：{}", decompressFilePath);
        }
        return true;
    }
}

單元測試

    String[] filesPathArray = new String[]{"D:\\core\\a.txt", "D:\\core\\b.txt"};
    String[] fileTarPath = new String[]{"D:\\core\\tarcompress.tar"};
    String compressTarTargetDirPath = "D:\\core\\tarcompress.tar.gz";
    String compressZipTargetDirPath = "D:\\core\\tarcompress.zip";
    String compressGzTargetDirPath = "D:\\core\\tarcompress3.gz";
    String compressGzTargetDirPath4 = "D:\\core\\tarcompress4.gz";
    String deCompressDirPath = "D:\\core";

    @Test
    public void testTarPack() throws Exception {
        boolean b = PackAndCompressionUtils.tarPack(filesPathArray, compressTarTargetDirPath);
        Assert.assertTrue(b);
    }

    @Test
    public void testTarUnpack() throws Exception {
        boolean b = PackAndCompressionUtils.tarUnpack(compressGzTargetDirPath, deCompressDirPath);
        Assert.assertTrue(b);
    }

    @Test
    public void testZipCompress() throws Exception {
        boolean b = PackAndCompressionUtils.zipCompress(filesPathArray, compressZipTargetDirPath);
        Assert.assertTrue(b);
    }

    @Test
    public void testZipDeCompress() throws Exception {
        boolean b = PackAndCompressionUtils.zipDecompress(compressZipTargetDirPath, deCompressDirPath);
        Assert.assertTrue(b);
    }

    @Test
    public void test() throws Exception {
        MyUnTarGzUtil.unTarGz(compressGzTargetDirPath,deCompressDirPath);
    }


    @Test
    public void testGzCompress() throws Exception {
        boolean b = PackAndCompressionUtils.gzipCompress(filesPathArray, compressGzTargetDirPath4);
        Assert.assertTrue(b);
    }

    @Test
    public void testGzDeCompress() throws Exception {
        boolean b = PackAndCompressionUtils.gzipDeCompress(compressTarTargetDirPath, deCompressDirPath);
        Assert.assertTrue(b);
    }