Java(Android)文件压缩和解压

今天遇到这么个需求，在网上找了个别人写的工具类，发现这个工具类对中文支持不好，遇到中文就出问题，后来把里面的编码格式都改成“UTF-8”，成功解决了，试了几次，都正常，特贴出来备用。不是我原创的，我也忘了在哪搬来的了，要是作者找我，我再声明好了。

package com.tools;

import android.text.TextUtils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 * Created by 月笼寒沙 on 2017/4/15.
 */

public class ZipUtil {
    
        private static final int BUFF_SIZE = 1024 * 1024; // 1M Byte
        /**
         * 批量压缩文件（夹）
         *
         * @param resFileList 要压缩的文件（夹）列表
         * @param zipFile 生成的压缩文件
         * @throws IOException 当压缩过程出错时抛出
         */
        public static void zipFiles(Collection<File> resFileList, File zipFile) throws IOException {
            ZipOutputStream zipout = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(
                    zipFile), BUFF_SIZE));
            for (File resFile : resFileList) {
                zipFile(resFile, zipout, "");
            }
            zipout.close();
        }
        /**
         * 批量压缩文件（夹）
         *
         * @param resFileList 要压缩的文件（夹）列表
         * @param zipFile 生成的压缩文件
         * @param comment 压缩文件的注释
         * @throws IOException 当压缩过程出错时抛出
         */
        public static void zipFiles(Collection<File> resFileList, File zipFile, String comment)
                throws IOException {
            ZipOutputStream zipout = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(
                    zipFile), BUFF_SIZE));
            for (File resFile : resFileList) {
                zipFile(resFile, zipout, "");
            }
            zipout.setComment(comment);
            zipout.close();
        }
        /**
         * 解压缩一个文件
         *
         * @param zipFile 压缩文件
         * @param folderPath 解压缩的目标目录
         * @throws IOException 当解压缩过程出错时抛出
         */
        public static void upZipFile(File zipFile, String folderPath) throws ZipException, IOException {
            File desDir = new File(folderPath);
            if (!desDir.exists()) {
                desDir.mkdirs();
            }
            ZipFile zf = new ZipFile(zipFile);
            for (Enumeration<?> entries = zf.entries(); entries.hasMoreElements();) {
                ZipEntry entry = ((ZipEntry)entries.nextElement());
                InputStream in = zf.getInputStream(entry);
                String str = folderPath + File.separator + entry.getName();
                str = new String(str.getBytes("UTF-8"), "UTF-8");
                File desFile = new File(str);
                if (!desFile.exists()) {
                    File fileParentDir = desFile.getParentFile();
                    if (!fileParentDir.exists()) {
                        fileParentDir.mkdirs();
                    }
                    desFile.createNewFile();
                }
                OutputStream out = new FileOutputStream(desFile);
                byte buffer[] = new byte[BUFF_SIZE];
                int realLength;
                while ((realLength = in.read(buffer)) > 0) {
                    out.write(buffer, 0, realLength);
                }
                in.close();
                out.close();
            }
        }
        /**
         * 解压文件名包含传入文字的文件
         *
         * @param zipFile 压缩文件
         * @param folderPath 目标文件夹
         * @param nameContains 传入的文件匹配名
         * @throws ZipException 压缩格式有误时抛出
         * @throws IOException IO错误时抛出
         */
        public static ArrayList<File> upZipSelectedFile(File zipFile, String folderPath,
                                                        String nameContains) throws ZipException, IOException {
            ArrayList<File> fileList = new ArrayList<File>();

            File desDir = new File(folderPath);
            if (!desDir.exists()) {
                desDir.mkdir();
            }
            ZipFile zf = new ZipFile(zipFile);
            for (Enumeration<?> entries = zf.entries(); entries.hasMoreElements();) {
                ZipEntry entry = ((ZipEntry)entries.nextElement());
                if (entry.getName().contains(nameContains)) {
                    InputStream in = zf.getInputStream(entry);
                    String str = folderPath + File.separator + entry.getName();
                    str = new String(str.getBytes("UTF-8"), "UTF-8");
                    // str.getBytes("GB2312"),"8859_1" 输出
                    // str.getBytes("8859_1"),"GB2312" 输入
                    File desFile = new File(str);
                    if (!desFile.exists()) {
                        File fileParentDir = desFile.getParentFile();
                        if (!fileParentDir.exists()) {
                            fileParentDir.mkdirs();
                        }
                        desFile.createNewFile();
                    }
                    OutputStream out = new FileOutputStream(desFile);
                    byte buffer[] = new byte[BUFF_SIZE];
                    int realLength;
                    while ((realLength = in.read(buffer)) > 0) {
                        out.write(buffer, 0, realLength);
                    }
                    in.close();
                    out.close();
                    fileList.add(desFile);
                }
            }
            return fileList;
        }
        /**
         * 获得压缩文件内文件列表
         *
         * @param zipFile 压缩文件
         * @return 压缩文件内文件名称
         * @throws ZipException 压缩文件格式有误时抛出
         * @throws IOException 当解压缩过程出错时抛出
         */
        public static ArrayList<String> getEntriesNames(File zipFile) throws ZipException, IOException {
            ArrayList<String> entryNames = new ArrayList<String>();
            Enumeration<?> entries = getEntriesEnumeration(zipFile);
            while (entries.hasMoreElements()) {
                ZipEntry entry = ((ZipEntry)entries.nextElement());
                entryNames.add(new String(getEntryName(entry).getBytes("UTF-8"), "UTF-8"));
            }
            return entryNames;
        }
        /**
         * 获得压缩文件内压缩文件对象以取得其属性
         *
         * @param zipFile 压缩文件
         * @return 返回一个压缩文件列表
         * @throws ZipException 压缩文件格式有误时抛出
         * @throws IOException IO操作有误时抛出
         */
        public static Enumeration<?> getEntriesEnumeration(File zipFile) throws ZipException,
                IOException {
            ZipFile zf = new ZipFile(zipFile);
            return zf.entries();
        }
        /**
         * 取得压缩文件对象的注释
         *
         * @param entry 压缩文件对象
         * @return 压缩文件对象的注释
         * @throws UnsupportedEncodingException
         */
        public static String getEntryComment(ZipEntry entry) throws UnsupportedEncodingException {
            return new String(entry.getComment().getBytes("UTF-8"), "UTF-8");
        }
        /**
         * 取得压缩文件对象的名称
         *
         * @param entry 压缩文件对象
         * @return 压缩文件对象的名称
         * @throws UnsupportedEncodingException
         */
        public static String getEntryName(ZipEntry entry) throws UnsupportedEncodingException {
            return new String(entry.getName().getBytes("UTF-8"), "UTF-8");
        }
        /**
         * 压缩文件
         *
         * @param resFile 需要压缩的文件（夹）
         * @param zipout 压缩的目的文件
         * @param rootpath 压缩的文件路径
         * @throws FileNotFoundException 找不到文件时抛出
         * @throws IOException 当压缩过程出错时抛出
         */
        private static void zipFile(File resFile, ZipOutputStream zipout, String rootpath)
                throws FileNotFoundException, IOException {
            rootpath = rootpath + (rootpath.trim().length() == 0 ? "" : File.separator)
                    + resFile.getName();
            rootpath = new String(rootpath.getBytes("UTF-8"), "UTF-8");
            if (resFile.isDirectory()) {
                File[] fileList = resFile.listFiles();
                for (File file : fileList) {
                    zipFile(file, zipout, rootpath);
                }
            } else {
                byte buffer[] = new byte[BUFF_SIZE];
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(resFile),
                        BUFF_SIZE);
                zipout.putNextEntry(new ZipEntry(rootpath));
                int realLength;
                while ((realLength = in.read(buffer)) != -1) {
                    zipout.write(buffer, 0, realLength);
                }
                in.close();
                zipout.flush();
                zipout.closeEntry();
            }
        }
    /**
     *
     * @param zipPath  zip文件的路径。
     * @param destDirPath  要存放解压出的文件的目录。
     * @return 解压成功返回true，否则返回false。
     */
    public static boolean deCompress(String zipPath,String destDirPath) {
        if(TextUtils.isEmpty(zipPath) || TextUtils.isEmpty(destDirPath)) {
            return false;
        }
        File zipFile = new File(zipPath);
        if(!zipFile.exists()) {
            return false;
        }
        File files =  new File(destDirPath);
        //如果存放解压文件的目录存在，就删除，再重建。但是，实际我却发现，目录的创建时间没有变，
        // 只有里面的文件时间是最新的，换句话说，表象上看，目录没有被删，只有文件更新成了最新的。原因未知。
        if(files.exists())
        {
            files.delete();
        }
        files.mkdirs();
        String destDir = destDirPath;
        if(!destDir.endsWith(File.separator)){
            destDir += File.separator;
        }
        ZipInputStream zipInStream = null;
        try {
            zipInStream= new ZipInputStream(new FileInputStream(zipFile));
            ZipEntry entry = zipInStream.getNextEntry();
            while (entry!=null) {
                String path = String.format("%s%s",destDir,entry.getName());
                File file = new File(path);
                if(entry.isDirectory()) {//如果是目录。没有该目录，创建该目录。有该目录，就什么也不做。
                    if(!file.exists())
                        file.mkdirs();
                } else {//如果是文件
                    if(!file.exists())
                        file.createNewFile();
                    FileOutputStream out = new FileOutputStream(file);
                    byte[] buffer = new byte[1024];
                    int len = -1;
                    try {
                        while ((len=zipInStream.read(buffer))!=-1){
                            out.write(buffer,0,len);
                            out.flush();
                        }
                    } catch (Exception e) {

                        return false;
                    } finally {
                        if(out!=null){
                            try {
                                out.close();
                            }catch (Exception e){

                                return false;
                            }
                        }
                    }
                }
                entry = zipInStream.getNextEntry();
            }
        } catch (Exception e) {

            return false;
        } finally {
            if(zipFile!=null) {
                try {
                    zipInStream.close();
                } catch (IOException e) {

                    return false;
                }
            }
        }

        return true;
    }



}