zip4j的正确使用方式

最新推荐文章于 2024-08-03 22:50:30 发布
最新推荐文章于 2024-08-03 22:50:30 发布
阅读量2.7k 收藏 2
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014686606/article/details/79743295
版权

网上有方法去获取zip4j的进度 的方式有缺陷 ,如果是在后台线程解压, 会有解压到中间一直到不了100%问题, 查看代码.


public void extractAll(final UnzipParameters unzipParameters, final String outPath, final ProgressMonitor progressMonitor, boolean runInThread) throws ZipException {
    CentralDirectory centralDirectory = this.zipModel.getCentralDirectory();
    if(centralDirectory != null && centralDirectory.getFileHeaders() != null) {
        final ArrayList fileHeaders = centralDirectory.getFileHeaders();
        progressMonitor.setCurrentOperation(1);
        progressMonitor.setTotalWork(this.calculateTotalWork(fileHeaders));
        progressMonitor.setState(1);
        if(runInThread) {
            Thread thread = new Thread("Zip4j") {
                public void run() {
                    try {
                        Unzip.this.initExtractAll(fileHeaders, unzipParameters, progressMonitor, outPath);
                        progressMonitor.endProgressMonitorSuccess();
                    } catch (ZipException var2) {
                        ;
                    }

                }
            };
            thread.start();
        } else {
            this.initExtractAll(fileHeaders, unzipParameters, progressMonitor, outPath);
        }

    } else {
        throw new ZipException("invalid central directory in zipModel");
    }
}

------------------

progressMonitor.endProgressMonitorSuccess();
之后执行
this.reset();
this.result = 0;
这样就把进度设置为0.导致外部线程读到的一直都是0

正确的做法


/**
 * Created by caosh on 2018-2-27.
 */

public class UnZipfile {

    private final static String TAG = "UnZipfile";
    private boolean isUnZip = false;
    private static UnZipfile instance;
    private int curpercent = 0;
    private UnzipFileListener mUnzipFileListener;
    private static  Thread thread;
    private Context mContext;
    private UnZipfile(Context context) {
        mContext = context;
    }
    public UnzipFileListener getmUnzipFileListener() {
        return mUnzipFileListener;
    }

    public void setmUnzipFileListener(UnzipFileListener mUnzipFileListener) {
        this.mUnzipFileListener = mUnzipFileListener;
    }

    final public static UnZipfile getInstance(Context context) {
        if (instance == null) {
            synchronized (UnZipfile.class) {
                if (instance == null) {
                    instance = new UnZipfile(context);
                }
            }
        }
        return instance;
    }

    public void unZip(String zipFilePath) {

        if (zipFilePath == null || zipFilePath.equals("")) {
            Log.d(TAG, "此解决路径错误：" + zipFilePath);
            Toast.makeText(mContext, mContext.getString(R.string.zip_file_path_err) + zipFilePath,Toast.LENGTH_LONG).show();
            return;
        }

        // 防止重复解压缩一个文件，造成系统异常
        if (!isUnZip()) {
            File zipfile = new File(zipFilePath);
            if (zipfile.exists()) {

                try {
                    // 由于系统的原因，此处不允许删除源文件，否则会造成解压缩不全
//             File file =new File(getDefaultPath(EstickerApp.getAppContext()));
//             if (!file.exists()){
//                file.mkdir();
//             }
                    unZip(zipfile, SourceUtil.getDataResourcePath(mContext)+ SourceUtil.SHOW_MODE + "_" + SourceUtil.getSoftVersion(), zipHandler,
                            false, false);
                } catch (ZipException e) {
                    e.printStackTrace();
                }

            } else {
                Log.d(TAG, zipFilePath + " 文件不存在");
                if(mContext!=null) {
                    Toast.makeText(mContext, zipFilePath + mContext.getString(R.string.zip_file_path_err),Toast.LENGTH_LONG).show();
                }
            }
        }
    }

    private Handler zipHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {

            Bundle bundle = msg.getData();

            switch (msg.what) {
                case CompressStatus.START:
                    Log.d(TAG, "unzip start");
                    if (mUnzipFileListener!=null){
                        mUnzipFileListener.onUnzipStart();
                    }
                    curpercent = 0;
                    setUnZip(true);
                    break;
                case CompressStatus.HANDLING: {
                    if (bundle != null) {

                        int percnt = bundle.getInt(CompressStatus.PERCENT);
                        if (curpercent != percnt) {
                            curpercent = percnt;
                            if (mUnzipFileListener!=null){
                                mUnzipFileListener.onUnziping(curpercent);
                            }
                            Log.d(TAG, "unzip persent =" + percnt);
                        }

                    }
                    break;
                }
                case CompressStatus.COMPLETED: {
                    if (mUnzipFileListener!=null){
                        mUnzipFileListener.onUnzipComplet();
                    }
                    Log.d(TAG, "unzip completed");
                    setUnZip(false);
                    break;
                }
                case CompressStatus.ERROR: {
                    if (bundle != null) {
                        if (mUnzipFileListener!=null){
                            mUnzipFileListener.onUnzipError();
                        }
                        Log.d(TAG, "unzip error msg =" + bundle.getString(CompressStatus.ERROR_COM));
                    }
                    curpercent = 0;
                    setUnZip(false);
                    break;
                }
                default:
                    break;
            }

            super.handleMessage(msg);
        }

    };
    /**
     * 封装不同的解压状态
     *
     **/
    public static class CompressStatus {
        public final static int START = 10000;
        public final static int HANDLING = 10001;
        public final static int COMPLETED = 10002;
        public final static int ERROR = 10003;

        public final static String PERCENT = "PERCENT";
        public final static String ERROR_COM = "ERROR";
    }

    public boolean isUnZip() {
        return isUnZip;
    }

    public void setUnZip(boolean isUnZip) {
        this.isUnZip = isUnZip;
    }
    /**
     * 无密码解压
     *
     * @param zipFile
     *            源文件
     * @param filePath
     *            解压文件路径
     * @param handler
     *            进度回调
     * @param isDeleteZip
     *            是否删除源文件
     * @param isEncryption
     *            文件是否加密
     * @throws ZipException
     */
    public static void unZip(final File zipFile, String filePath, final Handler handler, final boolean isDeleteZip,
                             boolean isEncryption) throws ZipException {
        unZip(zipFile, filePath, handler, isDeleteZip, "", isEncryption);
    }
    /**
     * 解压
     *
     * @param zipFile
     *            源文件
     * @param filePath
     *            解压文件路径
     * @param handler
     *            进度回调
     * @param isDeleteZip
     *            是否删除源文件
     * @param password
     *            解压密码
     * @param isEncryption
     *            文件是否加密
     * @throws ZipException
     */
    private static void unZip(final File zipFile, String filePath, final Handler handler, final boolean isDeleteZip,
                              String password, boolean isEncryption) throws ZipException {

        if (isEncryption) {
            final File decodeFile = new File(zipFile.getParentFile(), "test");
            try {
                // 解密
                decodeFile(zipFile, decodeFile, true);
            } catch (Exception e) {
                e.printStackTrace();
            }

            Log.d(TAG, "开始解压");
            ZipFile zFile = new ZipFile(decodeFile);
            zFile.setFileNameCharset("GBK");

            if (!zFile.isValidZipFile()) {
                throw new ZipException("exception!");
            }
            File destDir = new File(filePath); // 解压目录文件
            if (destDir.isDirectory() && !destDir.exists()) {
                destDir.mkdir();
            }
            if (zFile.isEncrypted()) {
                zFile.setPassword(password); // 设置解压密码
            }

            final ProgressMonitor progressMonitor = zFile.getProgressMonitor();

            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    Bundle bundle = null;
                    Message msg = null;
                    int percent = 0;
                    try {
                        Log.d(TAG,"try start");
                        int precentDone = 0;
                        if (handler == null) {
                            return;
                        }

                        boolean isUzipStart = false;
                        while (true) {
                            // 每隔50ms,发送一个解压进度出去
                            Thread.sleep(50);
                            int starState = progressMonitor.getState();
                            Log.d(TAG,"starState = "+starState);
                            if(starState == ProgressMonitor.STATE_BUSY){
                                Log.d(TAG,"isUzipStart = true");
                                isUzipStart = true;
                            }
                            precentDone = progressMonitor.getPercentDone();
                            Log.d(TAG,"precentDone = "+precentDone);
                            if (percent != precentDone) {
                                percent = precentDone;
                                // System.out.println(precentDone);
                                bundle = new Bundle();
                                bundle.putInt(CompressStatus.PERCENT, precentDone);
                                msg = new Message();
                                msg.what = CompressStatus.HANDLING;
                                msg.setData(bundle);
                                handler.sendMessage(msg); // 通过 Handler将进度扔出去
                            }
                            Log.d(TAG,"isUzipStart"+isUzipStart+"progressMonitor.getState()"+progressMonitor.getState());
                            if (precentDone >=100||(isUzipStart==true&& progressMonitor.getState()==ProgressMonitor.STATE_READY)) {

                                break;
                            }
                        }
                        Log.d(TAG,"handler CompressStatus.COMPLETED");
                        handler.sendEmptyMessage(CompressStatus.COMPLETED);
                    } catch (InterruptedException e) {
                        bundle = new Bundle();
                        bundle.putString(CompressStatus.ERROR_COM, e.getMessage());
                        msg = new Message();
                        msg.what = CompressStatus.ERROR;
                        msg.setData(bundle);
                        handler.sendMessage(msg);
                        e.printStackTrace();
                    } finally {
                        if (isDeleteZip) {
                            decodeFile.delete();// 将原压缩文件删除
                        }
                    }
                }
            });
            Log.d(TAG,"Thread start");
            thread.start();
            zFile.setRunInThread(true); // true 在子线程中进行解压 , false主线程中解压
            zFile.extractAll(filePath); // 将压缩文件解压到filePath中...
        } else {
            Log.d(TAG, "开始解压");
            ZipFile zFile = new ZipFile(zipFile);
            zFile.setFileNameCharset("GBK");

            if (!zFile.isValidZipFile()) {
                throw new ZipException("exception!");
            }
            File destDir = new File(filePath); // 解压目录文件
            if (destDir.isDirectory() && !destDir.exists()) {
                destDir.mkdir();
            }
            if (zFile.isEncrypted()) {
                zFile.setPassword(password); // 设置解压密码
            }

            final ProgressMonitor progressMonitor = zFile.getProgressMonitor();
            thread = new Thread(new Runnable() {

                @Override
                public void run() {
                    Bundle bundle = null;
                    Message msg = null;
                    int percent = 0;
                    try {
                        Log.d(TAG,"try start");
                        int precentDone = 0;
                        if (handler == null) {
                            return;
                        }
                        boolean isUzipStart = false;
                        while (true) {
                            // 每隔50ms,发送一个解压进度出去
                            Thread.sleep(50);
                            precentDone = progressMonitor.getPercentDone();
                            int starState = progressMonitor.getState();
                            Log.d(TAG,"starState = "+starState);
                            if(starState == ProgressMonitor.STATE_BUSY){
                                isUzipStart = true;
                                Log.d(TAG,"isUzipStart = true");
                            }
                            Log.d(TAG,"precentDone = "+precentDone);
                            // System.out.println(precentDone);
                            if (percent != precentDone) {
                                percent = precentDone;
                                bundle = new Bundle();
                                bundle.putInt(CompressStatus.PERCENT, precentDone);
                                msg = new Message();
                                msg.what = CompressStatus.HANDLING;
                                msg.setData(bundle);
                                handler.sendMessage(msg); // 通过 Handler将进度扔出去
                            }
                            Log.d(TAG,"progressMonitor.getResult() = "+progressMonitor.getResult());
                            progressMonitor.getResult();
                            Log.d(TAG,"progressMonitor.getState() = "+progressMonitor.getState());
                            Log.d(TAG,"progressMonitor.getWorkCompleted() = "+progressMonitor.getWorkCompleted());
                            Log.d(TAG,"progressMonitor.getCurrentOperation() "+progressMonitor.getCurrentOperation()) ;
                            Log.d(TAG,"isUzipStart"+isUzipStart+"progressMonitor.getState()"+progressMonitor.getState());
                            if (precentDone >= 100||(isUzipStart==true&& progressMonitor.getState()==ProgressMonitor.STATE_READY)) {
                                break;
                            }
                        }
                        Log.d(TAG,"handler CompressStatus.COMPLETED");
                        handler.sendEmptyMessage(CompressStatus.COMPLETED);
                    } catch (InterruptedException e) {
                        bundle = new Bundle();
                        bundle.putString(CompressStatus.ERROR_COM, e.getMessage());
                        msg = new Message();
                        msg.what = CompressStatus.ERROR;
                        msg.setData(bundle);
                        handler.sendMessage(msg);
                        e.printStackTrace();
                    } finally {
                        if (isDeleteZip) {
                            zipFile.delete();// 将原压缩文件删除
                        }
                    }
                }

            });
            Log.d(TAG,"Thread start");


            Log.d(TAG," handler.sendEmptyMessage(CompressStatus.START);");
            handler.sendEmptyMessage(CompressStatus.START);
            thread.start();
            zFile.setRunInThread(true); // true 在子线程中进行解压 ,
            // false主线程中解压
            zFile.extractAll(filePath); // 将压缩文件解压到filePath中...


        }

    }
    /**
     * 解密文件
     *
     * @param sourceFile
     *            加密文件
     * @param decodeFile
     *            解密文件
     * @param b
     *            是否删除加密文件
     */
    public static void decodeFile(File sourceFile, File decodeFile, boolean b) {
        byte[] bs = new byte[1024];
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try {
            in = new BufferedInputStream(new FileInputStream(sourceFile));
            out = new BufferedOutputStream(new FileOutputStream(decodeFile, false));
            while ((in.read(bs)) != -1) {
                for (int i = 0; i < bs.length; i++) {
                    out.write(bs[i] - 1);
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            try {
                out.flush();
                in.close();
                out.close();
            } catch (Exception e2) {
                // TODO: handle exception
                e2.printStackTrace();
            }
            if (b) {
                sourceFile.delete();
            }
        }

    }
    public  void stopUnzipFile(){
        if (thread!=null){
            thread.stop();
        }
    }
}



司马中达
关注
zip4j使用指南以及使用优化
06-09
本资源包括zip4j的开发代码以及开发时的优化以及开发测试报告！值得大家学习和共勉！
zip4j-1.3.2.jar 包下载，处理zip压缩文件的开发包
12-24
《使用zip4j库处理Java中的ZIP压缩文件》 在Java开发中，处理ZIP压缩文件是一项常见的任务。zip4j库作为一个强大的工具，为开发者提供了便捷的方法来读取、写入、创建、添加、提取、更新以及从ZIP文件中删除文件，...
zip4j包的简单使用
小强快跑~~
05-01 5482
Zip4j学习 之前开发过程中遇到一个需求：需要往压缩文件的某些目录下插入一些文件。之前使用了一些方案（例如ZipOutputStream），添加原理是新建一 个压缩文件，然后拷贝所有的文件，拷贝过程中添加新的文件进去，速度比较慢。后来发现了Zip4j，可以选择将文件只打包不压缩，然后可以特 别灵活的添加、删除文件。 zip4j功能比较强大，支持加密、解密压缩，支持文件的添加、删除等，所以想好好学习一波。 1.Zip4j介绍 zip4j官网：http://www.lingala.net/zip4j/
Java使用zip4j加密压缩和解压文件与文件夹
最新发布
棉花糖老丫
08-03 782
zip4j加密压缩和解压文件与文件夹
Zip4j简单使用
z2wenfa的博客
02-29 852
:zip4j是一个挺方便的压缩框架基本上只需要提供几个参数就可以使用了很方便 1压缩 /** * 压缩单个文件 * @param zipedFile * @param needZipFile */ public static void zipSingleFile(File zipedFile,File needZipFile) { ZipFile zipFile =
ZIP4j使用总结
weixin_44794056的博客
12-16 4580
zip4j ​ 在开发过程中，有时候会遇到上传压缩包，并对压缩包内文件进行某种处理的问题，这里只简述一种我自己遇到的案例；这里使用zip4j进行处理，好了废话不多说，直接进入案例。 首先引入所需依赖 <!--zip--> <dependency> <groupId>net.lingala.zip4j</groupId> <artifactId>zip4j</artifactId> &lt
Java 使用 zip4j 进行基本的压缩、解压、设置密码操作(-version zip4j-2.6+)
SPACE
06-15 2728
先看工具类 package space.util; import java.io.File; import java.util.List; import net.lingala.zip4j.ZipFile; import net.lingala.zip4j.model.ZipParameters; import net.lingala.zip4j.model.enums.AesKeyStrength; import net.lingala.zip4j.model.enums.EncryptionMe
zip4j-1.3.2.zip
06-05
1. **压缩操作**：ZIP4J提供了一种灵活的方式，可以将多个文件或整个目录结构打包成一个ZIP文件。你可以选择不同的压缩级别（从最快到最慢，但压缩率更高）以平衡速度和压缩效果。此外，ZIP4J还支持AES加密，可以为...
ZIP4J压缩包加密解密
11-01
2. 调用`setEncryptionMethod`方法设置加密方式，可以选择ZIP4J提供的`EncryptionMethod.ZIP_ENCRYPTION_METHOD_STANDARD`（传统ZIP加密）或`EncryptionMethod.ZIP_ENCRYPTION_METHOD_AES_128`、`AES_256`（AES加密...
ZIP4j 压缩与解压的实例详解
08-29
在使用ZIP4j进行压缩时，有三种基本的压缩方式。第一种是`COMP_STORE`（0），它只进行打包而不进行压缩，相当于存储模式。第二种是`COMP_DEFLATE`（8），这是默认的压缩方式，对应于类似于WinRAR或7-Zip等软件的...
zip4j压缩使用总结
qq_39464523的博客
11-22 2201
使用zip4j压缩文件并设置压缩包密码 addFiles, addStream，ZipOutputStream使用 net.lingala.zip4j.exception.ZipException: file name is empty for external stream net.lingala.zip4j.exception.ZipException: input file is null
Java压缩解压ZIP之Zip4j
04-18
NULL 博文链接：https://rensanning.iteye.com/blog/1836727
Java使用Zip4j压缩并加密文件
weixin_39282910的博客
05-06 482
使用zip4j压缩并加密文件
深入探讨Java压缩利器：net.lingala.zip4j.ZipFile的应用与实践
Java领域优秀创作者
06-11 1159
在现代软件开发中，数据压缩是一个常见且重要的任务。无论是减小文件大小以节省存储空间，还是将多个文件打包在一起以便于传输和分发，压缩技术都是不可或缺的。在Java世界中，`net.lingala.zip4j.ZipFile`库因其强大的功能和易用性，成为了许多开发者的首选。本文将深入探讨`net.lingala.zip4j.ZipFile`的使用方法，并通过详实的示例和代码解析，帮助读者全面掌握这一压缩工具的应用技巧。
Zip4j工具类学习笔记(帮助文档翻译)
山河已无恙
08-19 4054
zip工具类的帮助文档翻译
zip和unzip命令使用
清泉影月
01-07 1864
前言 压缩只为更方便地传输文件 1.压缩文件/目录 zip [参数] [压缩文件] [被压缩文件/目录] eg, zip test.zip run.py 当前目录下run.py文件压缩到test.zip文件 zip -r test.zip test/ 当前目录下test目录全部压缩到test.zip文件 2.压缩多个文件/目录 [被压缩文件/目录] 之间用空格分隔 zip t......
Linux下zip命令-不打包目标文件目录
LJS109的专栏
02-28 7555
需求：将/home/scan/result.txt文件打包为result.zip文件      使用方式1：zip -r  result.zip /home/scan/result.txt      使用方式2：zip -j result.zip /home/scan/result.txt      两种方式都可以实现需求，区别在于-r参数会递归的将目标文件的目录一起打包，因此生成的resu
ZIP4J压缩与解压缩
liang博客
09-15 2871
ZIP4j 压缩与解压的实例详解 使用的jar包：zip4j_2.6.4jar 1.导入maven依赖 <dependency> <groupId>net.lingala.zip4j</groupId> <artifactId>zip4j</artifactId> <version>1.3.2</version>
unzip命令参数
热门推荐
studyvcmfc的专栏
01-29 1万+
<br />功能说明：解压缩zip文件<br />语　　法：unzip [-cflptuvz][-agCjLMnoqsVX][-P ][.zip文件][文件][-d ][-x ] 或 unzip [-Z]<br />补充说明：unzip为.zip压缩文件的解压缩程式。<br />参　　数：<br />-c 将解压缩的结果显示到屏幕上，并对字符做适当的转换。<br />-f 更新现有的文件。<br />-l 显示压缩文件内所包含的文件。<br />-p 和-c参数类似，会将解压缩的结果显示到屏幕上，但不会执行
ZIP4j压缩与解压实战：加密、压缩级别解析
"这篇文档详细解析了如何使用ZIP4j库进行文件的压缩与解压缩操作，包括ZIP4j的基本功能、压缩方式、压缩级别、加密方法以及AES密钥强度等关键参数。" ZIP4j是一款Java库，专门用于处理ZIP文件的创建、添加、分卷、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值