利用JDK—java.util.zip包的方法实现压缩

最新推荐文章于 2022-07-01 11:46:33 发布
最新推荐文章于 2022-07-01 11:46:33 发布
阅读量276 收藏
点赞数
分类专栏： Java 文章标签： zip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calm_encode/article/details/119581829
版权

一 导入的包

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

二 代码实现

/**
 * 生成压缩文件 （zip，rar 格式）
 *
 */
@Slf4j
public class CompressUtil {

    private static final int BUFFER_SIZE = 2 * 1024;

    /**
     * @param path   要压缩的文件路径
     * @param format 生成的格式（zip、rar）等
     */
    public static void generateFile(String path, String format) throws Exception {

        File file = new File(path);
        // 压缩文件的路径不存在
        if (!file.exists()) {
            throw new Exception("路径 " + path + " 不存在文件，无法进行压缩...");
        }
        // 用于存放压缩文件的文件夹
        String generateFile = file.getParent() + File.separator + "CompressFile";
        File compress = new File(generateFile);
        // 如果文件夹不存在，进行创建
        if (!compress.exists()) {
            compress.mkdirs();
        }

        // 目的压缩文件
        String generateFileName = compress.getAbsolutePath() + File.separator + "AAA" + file.getName() + "." + format;

        // 输入流 表示从一个源读取数据
        // 输出流 表示向一个目标写入数据

        // 输出流
        FileOutputStream outputStream = new FileOutputStream(generateFileName);

        // 压缩输出流
        ZipOutputStream zipOutputStream = new ZipOutputStream(new BufferedOutputStream(outputStream));

        generateFile(zipOutputStream, file, "");

        System.out.println("源文件位置：" + file.getAbsolutePath() + "，目的压缩文件生成位置：" + generateFileName);
        // 关闭 输出流
        zipOutputStream.close();
    }

    /**
     * @param out  输出流
     * @param file 目标文件
     * @param dir  文件夹
     * @throws Exception
     */
    public static void generateFile(ZipOutputStream out, File file, String dir) throws Exception {

        // 当前的是文件夹，则进行一步处理
        if (file.isDirectory()) {
            //得到文件列表信息
            File[] files = file.listFiles();

            //将文件夹添加到下一级打包目录
            out.putNextEntry(new ZipEntry(dir + "/"));

            dir = dir.length() == 0 ? "" : dir + "/";

            //循环将文件夹中的文件打包
            for (int i = 0; i < files.length; i++) {
                generateFile(out, files[i], dir + files[i].getName());
            }

        } else { // 当前是文件

            // 输入流
            FileInputStream inputStream = new FileInputStream(file);
            // 标记要打包的条目
            out.putNextEntry(new ZipEntry(dir));
            // 进行写操作
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = inputStream.read(bytes)) > 0) {
                out.write(bytes, 0, len);
            }
            // 关闭输入流
            inputStream.close();
        }

    }


    public static void main(String[] args) {
        String path = "";
        String format = "rar";

        try {
            generateFile(path, format);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

    }

    /**
     * @param url 文件路径
     * @return inputStream/null
     */
    public InputStream getImg(String url) {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setReadTimeout(50000);
            connection.setConnectTimeout(50000);
            connection.setRequestMethod("GET");
            connection.addRequestProperty("User-Agent", "Mozilla / 4.76");
            connection.connect();
            System.out.print(url + "\n");
            System.out.print(connection.getResponseCode());
            System.out.print(connection.getResponseMessage());
            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                return connection.getInputStream();
            }
            connection.disconnect();
        } catch (IOException e) {
            System.out.println("获取网络图片出现异常，图片路径为：" + url);
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 生成png图片文件
     *
     * @param inStream
     * @param imageUrl
     * @param loanNo
     * @throws IOException
     */
    public void saveBit(InputStream inStream, String imageUrl, String loanNo) throws IOException {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        //创建一个Buffer字符串
        byte[] buffer = new byte[1024];
        //每次读取的字符串长度，如果为-1，代表全部读取完毕
        int len = 0;
        //使用一个输入流从buffer里把数据读取出来
        while ((len = inStream.read(buffer)) != -1) {
            //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
            outStream.write(buffer, 0, len);
        }
        //关闭输入流
        inStream.close();
        //把outStream里的数据写入内存

        //得到图片的二进制数据，以二进制封装得到数据，具有通用性
        byte[] data = outStream.toByteArray();
        //new一个文件对象用来保存图片，默认保存当前工程根目录
        //创建输出流
        File file = new File("./" + loanNo);
        if (!file.exists()) {
            file.mkdir();
        }
        File imageFile = new File(file.getPath() + "/" + imageUrl + ".png");

        FileOutputStream fileOutStream = new FileOutputStream(imageFile);
        //写入数据
        fileOutStream.write(data);
        fileOutStream.close();
        System.out.print("写入文件完成");
    }

    /**
     * 生成指定扩展名的文件
     *
     * @param inStream
     * @param fileName
     * @param loanNo
     * @param suffix
     * @throws IOException
     */
    public void saveFileBit(InputStream inStream, String fileName, String loanNo, String suffix) throws IOException {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        //创建一个Buffer字符串
        byte[] buffer = new byte[1024];
        //每次读取的字符串长度，如果为-1，代表全部读取完毕
        int len = 0;
        //使用一个输入流从buffer里把数据读取出来
        while ((len = inStream.read(buffer)) != -1) {
            //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
            outStream.write(buffer, 0, len);
        }
        //关闭输入流
        inStream.close();
        //把outStream里的数据写入内存

        //得到图片的二进制数据，以二进制封装得到数据，具有通用性
        byte[] data = outStream.toByteArray();
        //new一个文件对象用来保存图片，默认保存当前工程根目录
        //创建输出流
        File file = new File("./" + loanNo);
        if (!file.exists()) {
            file.mkdir();
        }
        File outPutFile = new File(file.getPath() + "/" + fileName + "." + suffix);

        FileOutputStream fileOutStream = new FileOutputStream(outPutFile);
        //写入数据
        fileOutStream.write(data);
        fileOutStream.close();
        System.out.print("写入文件完成");
    }


    /**
     * 将指定的网络文件写入指定文件
     *
     * @param destUrl
     */
    public void saveToFile(String destUrl, String name, String suffix) {
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        HttpURLConnection httpUrl = null;
        URL url = null;
        int BUFFER_SIZE = 1024;
        byte[] buf = new byte[BUFFER_SIZE];
        int size = 0;
        try {
            url = new URL(destUrl);
            httpUrl = (HttpURLConnection) url.openConnection();
            httpUrl.connect();
            System.out.print(httpUrl.getResponseMessage());
            bis = new BufferedInputStream(httpUrl.getInputStream());
            fos = new FileOutputStream("c:\\" + name + "." + suffix);
            while ((size = bis.read(buf)) != -1) {
                fos.write(buf, 0, size);
            }
            fos.flush();
        } catch (IOException e) {
        } catch (ClassCastException e) {
        } finally {
            try {
                //关闭流
                fos.close();
                bis.close();
                httpUrl.disconnect();
            } catch (IOException e) {
            } catch (NullPointerException e) {
            }
        }
    }

    /**
     * 将BufferedImage转换为InputStream
     *
     * @param image
     * @return
     */
    public InputStream bufferedImageToInputStream(BufferedImage image) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            ImageIO.write(image, "png", os);
            InputStream input = new ByteArrayInputStream(os.toByteArray());
            return input;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 生成压缩文件
     *
     * @param srcDir
     * @param out
     * @param fileName
     * @param keepDirStructure
     * @throws RuntimeException
     */
    public static void toZip(String srcDir, OutputStream out, String fileName, 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);
            compress(sourceFile, zos, fileName, keepDirStructure);
            long end = System.currentTimeMillis();
            System.out.println("压缩完成，耗时：" + (end - start) + " ms");
        } catch (Exception e) {
            log.error("", 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.getPath());
            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(), true);
                    } else {
                        compress(file, zos, file.getName(), false);
                    }
                }
            }
        }
    }

    /**
     * 下载文件
     *
     * @param os
     * @param path
     * @throws IOException
     */
    public void doDownTemplet(OutputStream os, String path) throws IOException {
        try {
            // 要下载的文件绝对路径
            File file = new File(path);
            InputStream ins;
            ins = new BufferedInputStream(new FileInputStream(file));
            byte[] buffer = new byte[ins.available()];
            ins.read(buffer);
            ins.close();

            OutputStream ous = new BufferedOutputStream(os);
            ous.write(buffer);
            ous.flush();
            ous.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static boolean delete(File file) {
        if (!file.exists()) {
            System.out.println("删除文件失败:" + file.getName() + "不存在！");
            return false;
        } else {
            if (file.isFile()) {
                return deleteFile(file.getPath());
            } else {
                return deleteDirectory(file.getName());
            }
        }
    }

    /**
     * 删除单个文件
     *
     * @param path 要删除的文件的路径
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String path) {
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        File file = new File(path);
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                System.out.println("删除单个文件" + file.getName() + "成功！");
                return true;
            } else {
                System.out.println("删除单个文件" + file.getName() + "失败！");
                return false;
            }
        } else {
            System.out.println("删除单个文件失败：" + file.getName() + "不存在！");
            return false;
        }
    }

    /**
     * 删除文件夹
     *
     * @param dir 文件夹
     * @return
     */
    public static boolean deleteDirectory(String dir) {
        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
        if (!dir.endsWith(File.separator)) {
            dir = dir + File.separator;
        }
        File dirFile = new File(dir);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
            System.out.println("删除目录失败：" + dir + "不存在！");
            return false;
        }
        boolean flag = true;
        // 删除文件夹中的所有文件包括子目录
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                // files[i].get
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            }
            // 删除子目录
            else if (files[i].isDirectory()) {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            }
        }
        if (!flag) {
            System.out.println("删除目录失败！");
            return false;
        }
        // 删除当前目录
        if (dirFile.delete()) {
            System.out.println("删除目录" + dir + "成功！");
            return true;
        } else {
            return false;
        }
    }
}

        更多细节，待续...

至学者
关注
专栏目录
java.util.zip压缩与解压缩
jellyjiao2008的专栏
05-14 1534
首先是压缩方法public byte[] compress(byte[] data) throws IOException { Deflater compresser = new Deflater();//用默认的压缩级别创建一个新的压缩器。 compresser.reset();//重置deflater，以便可以处理一组新的输入数据。 compresser.setInput(data,0,...
java.util.zip 解压缩文件，ZIP格式压缩文件.rar
07-10
Java解压缩文件，并以ZIP格式压缩文件，主要是使用java.util.zip 包中的类来实现解压、压缩文件功能，如果你对这个类并不太熟悉，你正好可以参考一下这个类是如何用的。
使用java.util.zip包来生成压缩文件
I'm Baymax D
08-19 491
简单总结，使用java.util.zip包来生成zip压缩文件主要有4个关键步骤： 1、定义压缩输出流，数据放入后再输出，会进行压缩； 2、放入一个文件实体，在此后直至下一次putNextEntry所有write的数据，均属于这个实体； 3、写入数据； 4、结束压缩；
完美java.util.zip使用，实现zip压缩和解压
Coder6527
10-13 980
之前找了很多demo代码在压缩中遇到各种问题，中文乱码、文本内容丢失等。 以下教程是本人亲自测试过，通过java.util.zip包实现java代码的文件zip压缩和解压： 1、压缩： 1）压缩一个文件 public static void main(String[] args) throws IOException { String sourceFile = "test1.txt"; FileOutputStream fos = new FileOutputStream(
java zip md5_java zip 工具类详解
weixin_30139729的博客
02-16 225
package com.topsoft.websites.utils;import java.io.*;import java.util.logging.Logger;import java.util.zip.*;/*** Created by sunyameng on 14-3-10.*/public class ZipUtil {private final static Logger logg...
zip文件压缩、解压工具(JDK)
java生涯
07-01 209
使用JDK的zip文件压缩、解压工具
tomcat启动报错：java.util.zip.ZipException的解决方法
08-27
解决`java.util.zip.ZipException`的方法有以下几种： 1. **检查和重新部署WAR文件**：首先，确保你的WAR文件是完整无损的。可以尝试在本地解压缩WAR文件，看看是否正常。如果在本地解压失败，那么问题可能就在WAR...
jdk8.zip jdk8.zip
08-31
JDK 8引入了java.time包，包含LocalDate、LocalTime、LocalDateTime等类，这些类提供了更直观、更强大的日期和时间操作功能，大大简化了相关开发工作。 此外，JDK 8还引入了接口默认方法和静态方法，这使得在不破坏...
jdk8压缩包.zip
12-09
5. **日期和时间API**：在`java.time`包下，JDK 8引入了全新的日期和时间API，替代了旧的`java.util.Date`和`java.util.Calendar`，提供了更加直观、易用且强大的日期和时间处理功能。 6. **默认方法**：在接口中...
jdk8.0.281.zip
08-03
1. 下载zip压缩文件“jdk8.0.281.zip”。 2. 解压缩到任意位置，例如C:\Program Files\Java。 3. 配置系统环境变量： - 添加新的系统变量JAVA_HOME，值设置为JDK的安装路径（例如C:\Program Files\Java\jdk8.0.281...
用java.util.zip包现数据压缩与解压
01-14
本文通过对数据压缩算法的简要介绍，然后以详细的示例演示了利用java.util.zip包实现数据的压缩与解压，并扩展到在网络传输方面如何应用java.util.zip包现数据压缩与解压
JavaUtil.rar
03-28
java自己封装的工具类，用于节省时间，提高效率，java常用工具类封装util.rar 一个项目不可能没有工具类，工具类的初衷是良好的，代码重用，但到了后面工具类越来越乱，有些项目工具类有几十个，看的眼花缭乱，还有不少重复。如何编写出好的工具类
java.util.zip
BLOG域名:programb.blog.csdn.net
05-12 229
Provides classes for reading and writing the standard ZIP and GZIP file formats. Also includes classes for compressing and decompressing data using the DEFLATE compression algorithm, which is used by the ZIP and GZIP file formats. Additionally, there are u
使用java.util.zip包压缩和解压缩文件
u010061734的专栏
10-04 513
Java API中的import java.util.zip.*;包下包含了Java对于压缩文件的所有相关操作。 我们可以使用该包中的方法，结合IO中的相关知识，进行文件的压缩和解压缩相关操作。 ZipFile java中的每一个压缩文件都是可以使用ZipFile来进行表示的。 File file = new File("F:/zippath.zip");
java.util.zip_java.util.zip
weixin_35651102的博客
02-15 695
使用java自带的类 java.util.zip进行文件/目录的压缩的话，有一点不足，不支持中文的名件/目录命名，如果有中文名，那么打包就会失败。本人经过一段时间的摸索和实践，发现在一般的Ant.jar类库中也有zip类，import org.apache.tools.zip.*，能够解决不支持中文文件目录的问题，同时，Ant的获得途径也比较多，一般的应用服务器中有这个包，实在不行去下载个tomc...
java java.util.zip,java使用java.util.zip将文件或是文件夹打包压缩成zip格式
weixin_32211137的博客
03-13 269
package cn.CodeSnippet.samples;import java.io.BufferedInputStream;import java.io.DataInputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io....
java加密文件夹_使用java.util.zip压缩文件夹，支持加密,增加描述
weixin_30162121的博客
02-21 912
导读热词下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import...
java实现将多个文件打包成zip压缩文件以及对压缩文件的加密
wjs7740的专栏
08-12 4344
如果仅仅需要对文件进行压缩
JDK *.*.*.**版本发布：解压即用的Java开发工具包
JDK 是用于支持 Java 程序开发的一套工具包，它包含了编译器（javac）、运行时环境（java）和核心库（Java API）等组件。在编程语言和运行环境日益发展的背景下，JDK 1.8 版本引入了许多新特性，并在后续的更新中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值