java压缩和解压

package cn.com.yusys.yusp.untiy.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

import java.io.*;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
/**
 * @DATE 2022/3/10 11:40
 * @USER luofeng
 * @NAME FileOprCommonUtils
 * @VERSION 1.0.0_V
 * @DESC
 */
@Slf4j
public class FileOprCommonUtils {

    /**
     * zip文件解压
     * 传入文件路径将文件解压缩并且返回所有文件路径列表
     * @param files
     * @return
     */
    public static String fileZip(List<String> files){

        //创建压缩流
        ZipOutputStream zipOutputStream =null;
        //创建输入流
        OutputStream outputStream= null;
        try {
            //初始化输入流
            outputStream = new FileOutputStream(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_ZIP_NAME);
            //初始化压缩流
            zipOutputStream = new ZipOutputStream(outputStream);

            for (String file : files) {
                File f  = new File(file);
                compress(f,zipOutputStream,f.getName(),true);
            }
            //关闭压缩文件流
            zipOutputStream.close();
            //关闭输出流
            outputStream.close();
        } catch (Exception e) {
            log.error("文件处理是失败！",e.getMessage());
        }finally {
            IOUtils.closeQuietly(zipOutputStream);
        }

        return "成功";
    }

    /**
     * txt文件生成
     * 根据传进来的字符串数据生成txt文件
     * @param datas
     * @return
     */
    public static String txtFileMake(List<String> datas){

        //文件输出流创建
        FileOutputStream fileOutputStream = null;
        try {
            //初始化
            fileOutputStream = new FileOutputStream(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_TXT_NAME);
//            OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream);

            StringBuffer buffer = new StringBuffer();
            //将文件写入buffer中
            for (String data : datas) {
//                writer.;
                buffer.append(data).append(CommonVarUtils.UntiyCommonFields.FILE_REG_NAME_WRITE);
            }
            //执行写入操作
            fileOutputStream.write(buffer.toString().getBytes());
            //刷新写入操作
            fileOutputStream.flush();
            //关闭流
            fileOutputStream.close();

        }catch (Exception e){
            log.error("文件处理失败！失败原因："+e.getMessage());
        }
        finally {
            IOUtils.closeQuietly(fileOutputStream);
        }
        return null;
    }

    /**
     * 文件读取
     * 读取文件内容，按行分割返回字符串数据
     * @param flie
     * @return
     */
    public static List<String> fileReader(String flie){

        //创建输入流对象
        FileInputStream fileInputStream = null;
        List<String> txtLists = new ArrayList<>();
        try {
            //初始化
            fileInputStream = new FileInputStream(flie);
            InputStreamReader reader = new InputStreamReader(fileInputStream);
            BufferedReader bufferedReader = new BufferedReader(reader);
            String readLine = null;
            while ((readLine = bufferedReader.readLine())!=null){
                if (StringUtils.isNotBlank(readLine)) {
                    txtLists.add(readLine);
                }
            }
            //关闭流
            bufferedReader.close();
            reader.close();
            fileInputStream.close();
        } catch (Exception e) {
            log.error("文件处理失败！原因是："+e.getMessage());
        }

        return txtLists;
    }


    public static String getZipFileName(String zipFileName){
        String[] split = zipFileName.split(".");
        return split[0];
    }


    /**
     * 递归压缩方法
     * @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[1024];
        if(sourceFile.isFile()){
            // 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
            zos.putNextEntry(new ZipEntry(name));
            // copy文件到zip输出流中
            int len;
            FileInputStream in = new FileInputStream(sourceFile);
            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(),KeepDirStructure);
                    } else {
                        compress(file, zos, file.getName(),KeepDirStructure);
                    }

                }
            }
        }
    }

    /**
     * 文件解压
     * @param url
     * @return
     */
    public static List<String> fileUnzip(String url){

        List<String> zipList = new ArrayList<>();
        try {
            File file = new File(url);
            ZipFile zipFile = new ZipFile(file);
            Enumeration<? extends ZipEntry> enumeration = zipFile.entries();
            while (enumeration.hasMoreElements()){
                ZipEntry zipEntry = enumeration.nextElement();
                if (zipEntry.isDirectory()){
                    file.mkdirs();
                }else {
                    //解压路径需要处理-这里的路径就是压缩文件的路径
                    String urlCode = url.substring(0,url.lastIndexOf("/"));
                    //创建新的解压文件
                    File tarFile = new File(urlCode+"/"+zipEntry.getName());

                    //解压文件父母节点必须存在
                    if (!tarFile.getParentFile().exists()){
                        tarFile.getParentFile().mkdirs();
                    }
                    //根据路径创建新的文件
                    tarFile.createNewFile();
                    zipList.add(tarFile.getAbsolutePath());
                    //将文件写入
                    InputStream is = zipFile.getInputStream(zipEntry);
                    FileOutputStream fos = new FileOutputStream(tarFile);
                    byte[] readByte = new byte[1024];

                    int len = -1;
                    while ((len = is.read(readByte))!=-1){
                        fos.write(readByte,0,len);
                    }
                    fos.close();
                    is.close();
                }
            }
            zipFile.close();

        } catch (Exception e) {
            log.error("文件处理失败！原因是："+e.getMessage());
        }finally {

        }
        return zipList;
    }
  /**
 * 文件压缩
 * 把传入进来的文件列表压缩成zip文件，并且返回路径
 * @param files
 * @return
 */
public static String fileZips(List<String> files){

    //创建压缩流
    ZipOutputStream zipOutputStream =null;
    //创建输入流
    OutputStream outputStream= null;
    try {
        //初始化输入流
        outputStream = new FileOutputStream(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_ZIP_CONTENT_NAME);
        //初始化压缩流
        zipOutputStream = new ZipOutputStream(outputStream);

        StringBuffer buffer = new StringBuffer();
        //将list文件写入到buffer中
        for (String s : files) {
            buffer.append(s).append(CommonVarUtils.UntiyCommonFields.FILE_REG_NAME_WRITE);
        }
        if (buffer.length()<=0){
            throw new Exception("待压缩文件大小为空！");
        }
        //创建压缩文件中文件
        zipOutputStream.putNextEntry(new ZipEntry(getZipFileName(CommonVarUtils.UntiyCommonFields.FILE_CREATE_ZIP_CONTENT_NAME)));
        //将文件写入压缩文件中
        zipOutputStream.write(buffer.toString().getBytes(CommonVarUtils.UntiyCommonFields.FILE_ENCODE_TYPE_UTF_8));
        //关闭文件写入的流
        zipOutputStream.closeEntry();
        //关闭压缩文件流
        zipOutputStream.close();
        //关闭输出流
        outputStream.close();
    } catch (Exception e) {
        log.error("文件处理是失败！",e.getMessage());
    }finally {
        IOUtils.closeQuietly(zipOutputStream);
    }

    return "成功";
}



//    public static void main(String[] args) {
//        List<String> str = new ArrayList<>();
//        for (int i = 0; i < 15; i++) {
//            str.add("第"+i+"测试数据啊，随便写的，不要在意！");
//        }
        String urlStr = CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_TXT_NAME;
        txtFileMake(str);
        fileReader(urlStr);
        fileZips(null);
//        fileUnzips(null);
//    }


//    public static List<String> fileUnzips(String data){
//
//        //文件压缩读取处理流
//        ZipInputStream zipInputStream = null;
//        List<String> zipList = new ArrayList<>();
//
//        try {
//            File file = new File(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_ZIP_NAME);
//            //文件处理流初始化
//            FileInputStream fis = new FileInputStream(file);
//            //压缩流初始化
//            zipInputStream = new ZipInputStream(fis);
//
//            //读取到的压缩文件中是否存在文件
//            ZipEntry zipEntry = zipInputStream.getNextEntry();
//
//            File file1
//            if (zipEntry.isDirectory()){
//
//            }
//
            zipInputStream.getNextEntry();
            if (null == zipEntry){
                throw new Exception("压缩文件内容为空！");
            }
            //读取压缩文件
            byte[] readByte = new byte[1024];

            StringBuffer buffer = new StringBuffer();
            while (zipInputStream.read(readByte)!=-1){
                buffer.append(new String(readByte,CommonVarUtils.UntiyCommonFields.FILE_ENCODE_TYPE_UTF_8));
            }
            //将压缩文件中的文件转换成list
            if (buffer.length()>0){
                String ziptxt = buffer.toString();
                String[] zipLists = ziptxt.split(CommonVarUtils.UntiyCommonFields.FILE_REG_NAME_READ);
                for (String list : zipLists) {
                    if (StringUtils.isNotBlank(list)){
                        zipList.add(list);
                    }
                }
            }
            //关闭流
            zipInputStream.close();
            fis.close();
//        } catch (Exception e) {
//            log.error("文件处理失败！原因是："+e.getMessage());
//        }finally {
//            IOUtils.closeQuietly(zipInputStream);
//        }
//
//        return null;
//    }
  //获取文件夹中的所有文件路径
   public List<String> getTxtUrlPath(String url){
        File file = new File(url);
        List<String> txtUrlPath= new ArrayList<>();
        if (file.exists()){
            File[] files = file.listFiles();
            if (files.length==0){
                return txtUrlPath;
            }else {
                for (File file1 : files) {
                    if (file1.isDirectory()){
                        getTxtUrlPath(file1.getAbsolutePath());
                    }else {
                        txtUrlPath.add(file1.getAbsolutePath());
                    }
                }
            }
        }
        return txtUrlPath;
    }
  //文件解压，第二种写法
  public static List<String> fileUnzipss2(String data){

        //文件压缩读取处理流
        ZipInputStream zipInputStream = null;
        List<String> zipList = new ArrayList<>();

        try {
            File file = new File(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+CommonVarUtils.UntiyCommonFields.FILE_CREATE_ZIP_NAME);
            //文件处理流初始化
            FileInputStream fis = new FileInputStream(file);
            //压缩流初始化
            zipInputStream = new ZipInputStream(fis);
            //读取到的压缩文件中是否存在文件
            ZipEntry zipEntry = null;
            File unZip = null;
            while((zipEntry = zipInputStream.getNextEntry())!=null){
                if (!zipEntry.isDirectory()){
                    unZip = new File(CommonVarUtils.UntiyCommonFields.FILE_PATH_SAVE+"/"+zipEntry.getName());
                    if (!unZip.getParentFile().exists()){
                        unZip.getParentFile().mkdirs();
                    }
                    unZip.createNewFile();
                    OutputStream os = new FileOutputStream(unZip);
                    BufferedOutputStream bos = new BufferedOutputStream(os);

                    //读取压缩文件
                    byte[] readByte = new byte[1024];

                    int len = -1;
                    while ((len = zipInputStream.read(readByte))!=-1){
                        bos.write(readByte,0,len);
                    }
                    bos.close();
                    os.close();
                    //关闭流
                }else {
                    file.mkdirs();
                }
            }

            zipInputStream.close();
            fis.close();


        } catch (Exception e) {
            log.error("文件处理失败！原因是："+e.getMessage());
        }finally {
            IOUtils.closeQuietly(zipInputStream);
        }

        return null;
    }
}