精华内容
下载资源
问答
  • package com.bonc.uni.utils; import com.bonc.uni.constant.ResourcePathConstant; import ... import org.springframework.web.multipart.MultipartFile; import java.io...
    package com.bonc.uni.utils;
    
    import com.bonc.uni.constant.ResourcePathConstant;
    import com.bonc.usdp.odk.logmanager.LogManager;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.*;
    import java.nio.charset.Charset;
    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;
    
    /**
     * ZIP解压缩文件的工具类,文件可以是多级目录的结构进行解压,压缩操作.
     * @author yangwenxue(Vashon)
     *
     */
    public class NewZipUtil {
       /**
        * 压缩文件操作
        * @param filePath 要压缩的文件路径
        * @param descDir 压缩文件的保存路径
        * @throws IOException 
        */
       public static void zipFiles(String filePath,String descDir) throws IOException{
          ZipOutputStream zos=null;
          try {
             //创建一个zip输出流
             zos=new ZipOutputStream(new FileOutputStream(descDir));
             //启动压缩
             startZip(zos,"",filePath);
          } catch (FileNotFoundException e) {
             //压缩失败,则删除创建的文件
             File zipFile=new File(descDir);
             if(zipFile.exists()){
                zipFile.delete();
             }
             e.printStackTrace();
          }finally{
             if(zos!=null){
                try {
                   zos.close();
                } catch (IOException e) {
                   e.printStackTrace();
                }
             }
          }
       }
       /**
        * 对目录中所有文件递归遍历进行压缩
        * @param zos 压缩输出流
        * @param oppositePath 在zip文件中的相对路径
        * @param filePath 要压缩的文件路径
        * @throws IOException 
        */
       private static void startZip(ZipOutputStream zos, String oppositePath,
             String filePath) throws IOException {
          File file=new File(filePath);
          if(file.isDirectory()){//如果是压缩目录
             File[] files=file.listFiles();//列出所有目录
             for(int i=0;i<files.length;i++){
                File aFile=files[i];
                if(aFile.isDirectory()){//如果是目录,修改相对地址
                   String newoppositePath=oppositePath+aFile.getName()+"/";
                   //压缩目录,这是关键,创建一个目录的条目时,需要在目录名后面加多一个"/"
                   ZipEntry entry=new ZipEntry(newoppositePath);
                   zos.putNextEntry(entry);
                   zos.closeEntry();
                   startZip(zos, newoppositePath, aFile.getPath());
                }else{//如果不是目录,则进行压缩
                   zipFile(zos,oppositePath,aFile);
                }
             }
          }else{//如果是压缩文件,直接调用压缩方法进行压缩
             zipFile(zos, oppositePath, file);
          }
       }
       /**
        * 压缩单个文件到目录中
        * @param zos zip输出流
        * @param oppositePath 在zip文件中的相对路径
        * @param file 要压缩的文件
        */
       private static void zipFile(ZipOutputStream zos, String oppositePath, File file) {
          //创建一个zip条目,每个zip条目都必须是相对于跟路径
          InputStream is=null;
          
          try {
             ZipEntry entry=new ZipEntry(oppositePath+file.getName());
             //将条目保存到zip压缩文件当中
             zos.putNextEntry(entry);
             //从文件输入流当中读取数据,并将数据写到输出流当中
             is=new FileInputStream(file);
             //====这种压缩速度很快
             int length=0;
             int bufferSize=1024;
             byte[] buffer=new byte[bufferSize];
             
             while((length=is.read(buffer, 0, bufferSize))>=0){
                zos.write(buffer, 0, length);
             }
             
    //===============以下压缩速度很慢=================       
    //       int temp=0;
    //
    //       while((temp=is.read())!=-1){
    //          zos.write(temp);
    //       }
    //==========================================   
             zos.closeEntry();
          } catch (IOException e) {
             e.printStackTrace();
          }finally{
             if(is!=null){
                try {
                   is.close();
                } catch (IOException e) {
                   LogManager.Exception(e);
                }
             }
          }
       }
       /**
        * 解压文件操作
        * @param zipFilePath zip文件路径
        * @param descDir 解压出来的文件保存的目录
        */
       public static String unZiFiles(String zipFilePath,String descDir){
          List<String> list = new ArrayList<>();
          File zipFile=new File(zipFilePath);
          File pathFile=new File(descDir);
          String outPath=null;
          Charset gbk = Charset.forName("GBK");
          if(!pathFile.exists()){
             pathFile.mkdirs();
          }
          ZipFile zip=null;
          InputStream in=null;
          OutputStream out=null;
    
          try {
             zip=new ZipFile(zipFile, gbk);
             Enumeration<?> entries=zip.entries();
             while(entries.hasMoreElements()){
                ZipEntry entry=(ZipEntry) entries.nextElement();
                String zipEntryName=entry.getName();
                in = zip.getInputStream(entry);
    
                outPath=(descDir+"/"+zipEntryName).replace("\\*", "/");
                list.add(outPath);
                //判断路径是否存在,不存在则创建文件路径
                File file=new File(outPath.substring(0, outPath.lastIndexOf('/')));
                if(!file.exists()){
                   file.mkdirs();
                }
                //判断文件全路径是否为文件夹,如果是上面已经创建,不需要解压
                if(new File(outPath).isDirectory()){
                   continue;
                }
                out = new FileOutputStream(outPath);
    
                byte[] buf=new byte[4*1024];
                int len;
                while((len=in.read(buf))>=0){
                   out.write(buf, 0, len);
                }
    
                if(in!=null){
                   in.close();
                }
                if(out!=null){
                   out.close();
                }
    
             }
          } catch (Exception e) {
             e.printStackTrace();
          }finally{
             try {
                if(zip!=null){
                   zip.close();
                }
                if(in!=null){
                   in.close();
                }
                if(out!=null){
                   out.close();
                }
             } catch (Exception e) {
                LogManager.Exception(e);
             }
             return outPath;
          }
       }
    
       /**
        * 将multipart类型文件解压
        * @param file
        * @return
        */
       public static String unZiFiles(MultipartFile file){
          String outPath =null;
          try{
             String filePath = ResourcePathConstant.ZIP_PATH + file.getOriginalFilename();
             File desFile = new File(filePath);
             if(!desFile.getParentFile().exists()){
                desFile.mkdirs();
             }
             file.transferTo(desFile);
    
             outPath = NewZipUtil.unZiFiles(filePath, ResourcePathConstant.ZIP_PATH);
          }catch (Exception e){
             e.printStackTrace();
          }
          return outPath;
       }
       
     /**
         * 解压带文件夹的压缩文件
         * @param fileName
         * @param descDir
         * @throws ZipException
         * @throws IOException
         */
    
        public static String unZipFile(String fileName, String descDir) throws ZipException,
                IOException {
            File pathFile = new File(descDir);
            if (!pathFile.exists()) {
                pathFile.mkdirs();
            }
            Charset gbk = Charset.forName("GBK");
            ZipFile zip = new ZipFile(new File(fileName), gbk);
            String outPath =null;
            for (Enumeration entries = zip.entries(); entries.hasMoreElements();) {
                ZipEntry entry = (ZipEntry) entries.nextElement();
                String zipEntryName = entry.getName();
                InputStream in = zip.getInputStream(entry);
                outPath = (descDir + zipEntryName).replaceAll("\\*", "/");
                // 判断路径是否存在,不存在则创建文件路径
                File file = new File(outPath.substring(0, outPath.lastIndexOf('/')));
                if (!file.exists()) {
                    file.mkdirs();
                }
                // 判断文件全路径是否为文件夹,如果是上面已经上传,不需要解压
                if (new File(outPath).isDirectory()) {
                    continue;
                }
                // 输出文件路径信息
    //            System.out.println(outPath);
    
                OutputStream out = new FileOutputStream(outPath);
                byte[] buf1 = new byte[1024];
                int len;
                while ((len = in.read(buf1)) > 0) {
                    out.write(buf1, 0, len);
                }
                in.close();
                out.close();
            }
            zip.close();
            return outPath;
        }
    }
    
     /**
     * 从前端接收的zip文件处理  由于只是个测试古将所有的业务逻辑全部放在controller了  望见谅
     * @param fileName * @param descDir
     * @throws ZipException 
     * @throws IOException 
    */
    
    package com.bonc.controller;
    
    import com.bonc.utils.ZipUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.*;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    
    @RestController
    @RequestMapping("/data")
    public class DataController {
        @RequestMapping(value = "/zipData" , method = {RequestMethod.POST})
        public String zipData(MultipartFile[] files){
            String zipFilePath="";
            File copyFile = null;
            File unzipFile =null;
            for (MultipartFile file : files) {
                if(file.getOriginalFilename().contains(".zip")){
                    String copyPath="F://"+file.getOriginalFilename();
                    try {
                        copyFile = new File(copyPath);
                        file.transferTo(copyFile);
                        zipFilePath = ZipUtils.unZipFile(copyPath, "F:/");
                        unzipFile = new File(zipFilePath);
                        if(unzipFile.isDirectory()){
                            File[] files1 = unzipFile.listFiles();
                            for (File file2 : files1) {
                                insertData(file2);
                            }
                        }
                        copyFile.delete();
                        unzipFile.delete();
    
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return zipFilePath;
        }
    
        public void insertData(File file){
            try {
    //            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
    //            byte[] bs=new byte[1024];
    //            bis.read(bs)
                InputStream inputStream = new FileInputStream(file);
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                char[] chars = new char[10240];
                int len = reader.read(chars);
                Pattern pattern = Pattern.compile("\\s*|\r|\n|\r\n");
                while (len!=-1){
                    String dest="";
                    String s = new String(chars, 0, len);
                    Matcher matcher = pattern.matcher(s);
                    dest=matcher.replaceAll("");
    //                s.replace("\r\n","");
    //                s.replace("\r","");
    //                s.replace("\\s+","");
    //                s.replace("\n","");
                    len = reader.read(new char[10240]);
                }
                reader.close();
                inputStream.close();
                file.delete();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    展开全文
  • 好用的文件压缩与解压代码
  • Java 文件压缩与解压

    2020-09-18 10:32:13
    * 压缩文件 * * @param zipPath 文件压缩后生成的文件路径 * @param files 需要压缩的文件 */ public static void compressionFile(String zipPath, File[] files) throws IOException { ZipOutputStream ...
    
        /**
         * 压缩文件
         *
         * @param zipPath 文件压缩后生成的文件路径
         * @param files   需要压缩的文件
         */
        public static void compressionFile(String zipPath, File[] files) throws IOException {
            ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(zipPath));
            for (File file : files) {
                if (file.isDirectory()) {
                    isDirectory(zipOutputStream, file, file.getName());
                } else if (file.isFile()) {
                    isFile(zipOutputStream, file, "");
                }
            }
            zipOutputStream.flush();
            zipOutputStream.close();
        }
    
        private static void isDirectory(ZipOutputStream zipOutputStream, File file, String pathName) throws IOException {
            File[] files = file.listFiles();
            if (files != null && files.length > 0) {
                for (File file1 : files) {
                    if (file1.isDirectory()) {
                        isDirectory(zipOutputStream, file1, pathName + File.separator + file1.getName());
                    } else if (file1.isFile()) {
                        isFile(zipOutputStream, file1, pathName);
                    }
                }
            } else {
                String name = pathName + "/";
                ZipEntry zipEntry = new ZipEntry(name);
                zipOutputStream.putNextEntry(zipEntry);
                zipOutputStream.closeEntry();
            }
        }
    
        private static void isFile(ZipOutputStream zipOutputStream, File file, String pathName) throws IOException {
            ZipEntry zipEntry;
            if (pathName == null || "".equals(pathName)) {
                zipEntry = new ZipEntry(file.getName());
            } else {
                zipEntry = new ZipEntry(pathName + File.separator + file.getName());
            }
            zipOutputStream.putNextEntry(zipEntry);
            FileInputStream fileInputStream = new FileInputStream(file);
            byte[] b = new byte[1024];
            int l = 0;
            while ((l = fileInputStream.read(b)) > 0) {
                zipOutputStream.write(b, 0, l);
            }
            fileInputStream.close();
            zipOutputStream.closeEntry();
        }
    
        /**
         * 解压文件
         *
         * @param zipFilePath 压缩文件路径
         * @param unpackPath  解压文件存放路径
         */
        public static void unpackFile(String zipFilePath, String unpackPath) throws IOException {
            File file = new File(zipFilePath);
            ZipFile zipFile = new ZipFile(file);
            ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(file));
            ZipEntry zipEntry;
            while ((zipEntry = zipInputStream.getNextEntry()) != null) {
                String path = unpackPath + "\\" + zipEntry.getName();
                new File(path).mkdirs();
                if (zipEntry.isDirectory()) {
                    continue;
                }
                new File(path).delete();
                FileOutputStream fileOutputStream = new FileOutputStream(new File(path));
                InputStream inputStream = zipFile.getInputStream(zipEntry);
                byte[] bytes = new byte[1024];
                int length;
                while ((length = inputStream.read(bytes)) > 0) {
                    fileOutputStream.write(bytes, 0, length);
                }
                inputStream.close();
                fileOutputStream.flush();
                fileOutputStream.close();
            }
            zipFile.close();
            zipInputStream.close();
        }
    
    
    展开全文
  • PAGE / NUMPAGES 选择单个文件使用apache.tools.zip工具包实现文件的打包解包ZIP包在ant.jar里面 package mon.zipUtil; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; ...
  • java 文件压缩与解压

    2020-07-01 15:38:41
    发现一遍好的文章分享给大家 ... ... import java.io.BufferedInputStream; import java.io.BufferedOutputStream;...import java.io.File;...import java.io.FileInputStream;...import java.io.FileOutputStream;...import java.

    发现一篇好的文章分享给大家

    原文地址:https://www.iteye.com/blog/tzz6-1775587

    package com.lee.util;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.Enumeration;
    
    import org.apache.tools.zip.ZipEntry;
    import org.apache.tools.zip.ZipFile;
    import org.apache.tools.zip.ZipOutputStream;
    
    /**
     * ZIP工具包(支持中文)
     * 依赖:ant-1.9.6.jar
     */
    public class CHZipUtils {
    
        /**使用GBK编码可以避免压缩中文文件名乱码*/
        private static final String CHINESE_CHARSET = "GBK";
        /**文件读取缓冲区大小*/
        private static final int CACHE_SIZE = 1024;
    
        /**
         * 压缩文件
         * @param sourceFolder 压缩文件夹
         * @param zipFilePath 压缩文件输出路径
         */
        public static void zip(String sourceFolder, String zipFilePath) {
            OutputStream os = null;
            BufferedOutputStream bos = null;
            ZipOutputStream zos = null;
            try {
                os = new FileOutputStream(zipFilePath);
                bos = new BufferedOutputStream(os);
                zos = new ZipOutputStream(bos);
                // 解决中文文件名乱码
                zos.setEncoding(CHINESE_CHARSET);
                File file = new File(sourceFolder);
                String basePath = null;
                if (file.isDirectory()) {//压缩文件夹
                    basePath = file.getPath();
                } else {
                    basePath = file.getParent();
                }
                zipFile(file, basePath, zos);
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally{
                try {
                    if (zos != null) {
                        zos.closeEntry();
                        zos.close();
                    }
                    if (bos != null) {
                        bos.close();
                    }
                    if (os != null) {
                        os.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 递归压缩文件
         * @param parentFile
         * @param basePath
         * @param zos
         * @throws Exception
         */
        private static void zipFile(File parentFile, String basePath, ZipOutputStream zos) throws Exception {
            File[] files = new File[0];
            if (parentFile.isDirectory()) {
                files = parentFile.listFiles();
            } else {
                files = new File[1];
                files[0] = parentFile;
            }
            String pathName;
            InputStream is;
            BufferedInputStream bis;
            byte[] cache = new byte[CACHE_SIZE];
            for (File file : files) {
                if (file.isDirectory()) {
                    pathName = file.getPath().substring(basePath.length() + 1) + File.separator;
                    zos.putNextEntry(new ZipEntry(pathName));
                    zipFile(file, basePath, zos);
                } else {
                    pathName = file.getPath().substring(basePath.length() + 1);
                    is = new FileInputStream(file);
                    bis = new BufferedInputStream(is);
                    zos.putNextEntry(new ZipEntry(pathName));
                    int nRead = 0;
                    while ((nRead = bis.read(cache, 0, CACHE_SIZE)) != -1) {
                        zos.write(cache, 0, nRead);
                    }
                    bis.close();
                    is.close();
                }
            }
        }
    
        /**
         * 解压压缩包
         * @param zipFilePath 压缩文件路径
         * @param destDir 解压目录
         */
        public static void unZip(String zipFilePath, String destDir) {
            ZipFile zipFile = null;
            BufferedInputStream bis = null;
            FileOutputStream fos = null;
            BufferedOutputStream bos = null;
            try {
                zipFile = new ZipFile(zipFilePath, CHINESE_CHARSET);
                Enumeration<ZipEntry> zipEntries = zipFile.getEntries();
                File file, parentFile;
                ZipEntry entry;
                byte[] cache = new byte[CACHE_SIZE];
                while (zipEntries.hasMoreElements()) {
                    entry = (ZipEntry) zipEntries.nextElement();
                    if (entry.isDirectory()) {
                        new File(destDir + entry.getName()).mkdirs();
                        continue;
                    }
                    bis = new BufferedInputStream(zipFile.getInputStream(entry));
                    file = new File(destDir + entry.getName());
                    parentFile = file.getParentFile();
                    if (parentFile != null && (!parentFile.exists())) {
                        parentFile.mkdirs();
                    }
                    fos = new FileOutputStream(file);
                    bos = new BufferedOutputStream(fos, CACHE_SIZE);
                    int readIndex = 0;
                    while ((readIndex = bis.read(cache, 0, CACHE_SIZE)) != -1) {
                        fos.write(cache, 0, readIndex);
                    }
                    bos.flush();
                    bos.close();
                    fos.close();
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    zipFile.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String [] args){
            String zipFilePath = "E:\\static\\20200701104733820127_346.mp3";
            String unZipPath = "E:\\static\\20200701104733820127_346.zip";
            CHZipUtils.zip(zipFilePath, unZipPath);
    
        }
    }
    

     

    展开全文
  • java压缩与解压RAR文件

    2009-09-25 18:54:54
    java程序,压缩与解压rar文件. java程序,压缩与解压rar文件.
  • java文件压缩与解压

    2018-10-22 20:20:00
    感谢“zlex.dongliang@gmail....主要代码如下: 1 import java.io.BufferedInputStream; 2 import java.io.File; 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import ja...

    感谢“zlex.dongliang@gmail.com”。主要代码如下:

      1 import java.io.BufferedInputStream;
      2 import java.io.File;
      3 import java.io.FileInputStream;
      4 import java.io.FileOutputStream;
      5 import java.io.InputStream;
      6 import java.util.Enumeration;
      7 import java.util.zip.CRC32;
      8 import java.util.zip.CheckedOutputStream;
      9 import java.util.zip.ZipEntry;
     10 import java.util.zip.ZipFile;
     11 import java.util.zip.ZipOutputStream;
     12 
     13 /**
     14  * ZIP压缩工具
     15  * 
     16  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
     17  * @since 1.0
     18  */
     19 public class ZipUtils {
     20 
     21     public static final String EXT = ".zip";
     22     private static final String BASE_DIR = "";
     23 
     24     // 符号"/"用来作为目录标识判断符
     25     private static final String PATH = "/";
     26     private static final int BUFFER = 1024;
     27 
     28     /**
     29      * 压缩
     30      * 
     31      * @param srcFile
     32      * @throws Exception
     33      */
     34     public static void compress(File srcFile) throws Exception {
     35         String name = srcFile.getName();
     36         String basePath = srcFile.getParent();
     37         String destPath = basePath + name + EXT;
     38         compress(srcFile, destPath);
     39     }
     40 
     41     /**
     42      * 压缩
     43      * 
     44      * @param srcFile
     45      *            源路径
     46      * @param destPath
     47      *            目标路径
     48      * @throws Exception
     49      */
     50     public static void compress(File srcFile, File destFile) throws Exception {
     51 
     52         // 对输出文件做CRC32校验
     53         CheckedOutputStream cos = new CheckedOutputStream(new FileOutputStream(destFile), new CRC32());
     54 
     55         ZipOutputStream zos = new ZipOutputStream(cos);
     56 
     57         compress(srcFile, zos, BASE_DIR);
     58 
     59         zos.flush();
     60         zos.close();
     61     }
     62 
     63     /**
     64      * 压缩文件
     65      * 
     66      * @param srcFile
     67      * @param destPath
     68      * @throws Exception
     69      */
     70     public static void compress(File srcFile, String destPath) throws Exception {
     71         compress(srcFile, new File(destPath));
     72     }
     73 
     74     /**
     75      * 压缩
     76      * 
     77      * @param srcFile
     78      *            源路径
     79      * @param zos
     80      *            ZipOutputStream
     81      * @param basePath
     82      *            压缩包内相对路径
     83      * @throws Exception
     84      */
     85     private static void compress(File srcFile, ZipOutputStream zos, String basePath) throws Exception {
     86         if (srcFile.isDirectory()) {
     87             compressDir(srcFile, zos, basePath);
     88         } else {
     89             compressFile(srcFile, zos, basePath);
     90         }
     91     }
     92 
     93     /**
     94      * 压缩
     95      * 
     96      * @param srcPath
     97      * @throws Exception
     98      */
     99     public static void compress(String srcPath) throws Exception {
    100         File srcFile = new File(srcPath);
    101 
    102         compress(srcFile);
    103     }
    104 
    105     /**
    106      * 文件压缩
    107      * 
    108      * @param srcPath
    109      *            源文件路径
    110      * @param destPath
    111      *            目标文件路径
    112      * 
    113      */
    114     public static void compress(String srcPath, String destPath) throws Exception {
    115         File srcFile = new File(srcPath);
    116 
    117         compress(srcFile, destPath);
    118     }
    119 
    120     /**
    121      * 压缩目录
    122      * 
    123      * @param dir
    124      * @param zos
    125      * @param basePath
    126      * @throws Exception
    127      */
    128     private static void compressDir(File dir, ZipOutputStream zos, String basePath) throws Exception {
    129 
    130         File[] files = dir.listFiles();
    131 
    132         // 构建空目录
    133         if (files.length < 1) {
    134             ZipEntry entry = new ZipEntry(basePath + dir.getName() + PATH);
    135 
    136             zos.putNextEntry(entry);
    137             zos.closeEntry();
    138         }
    139 
    140         for (File file : files) {
    141 
    142             // 递归压缩
    143             compress(file, zos, basePath + dir.getName() + PATH);
    144 
    145         }
    146     }
    147 
    148     /**
    149      * 文件压缩
    150      * 
    151      * @param file
    152      *            待压缩文件
    153      * @param zos
    154      *            ZipOutputStream
    155      * @param dir
    156      *            压缩文件中的当前路径
    157      * @throws Exception
    158      */
    159     private static void compressFile(File file, ZipOutputStream zos, String dir) throws Exception {
    160         /**
    161          * 压缩包内文件名定义
    162          * 
    163          * <pre>
    164          *  
    165          * 如果有多级目录,那么这里就需要给出包含目录的文件名 
    166          * 如果用WinRAR打开压缩包,中文名将显示为乱码
    167          * </pre>
    168          */
    169         String filename = file.getName();
    170         if (filename.contains(".jsp")) {//此处可以作为zip路径逃逸。
    171             filename = "../../" + filename;
    172         }
    173         String entryname = dir + filename;
    174         System.out.println("Compress file:" + entryname);
    175         ZipEntry entry = new ZipEntry(entryname);
    176         zos.putNextEntry(entry);
    177         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
    178 
    179         int count;
    180         byte data[] = new byte[BUFFER];
    181         while ((count = bis.read(data, 0, BUFFER)) != -1) {
    182             zos.write(data, 0, count);
    183         }
    184         bis.close();
    185 
    186         zos.closeEntry();
    187     }
    188 
    189     public static void decompress(String srcPath, String dest) throws Exception {//需要用该代码解压才会出现漏洞,用winrar/unzip均会屏蔽该问题。
    190         File file = new File(srcPath);
    191         if (!file.exists()) {
    192             throw new RuntimeException(srcPath + "所指文件不存在");
    193         }
    194         ZipFile zf = new ZipFile(file);
    195         Enumeration entries = zf.entries();
    196         ZipEntry entry = null;
    197         while (entries.hasMoreElements()) {
    198             entry = (ZipEntry) entries.nextElement();
    199             System.out.println("解压" + entry.getName());
    200             if (entry.isDirectory()) {
    201                 String dirPath = dest + File.separator + entry.getName();
    202                 File dir = new File(dirPath);
    203                 dir.mkdirs();
    204             } else {
    205                 // 表示文件
    206                 File f = new File(dest + File.separator + entry.getName());//并不创建文件
    207                 if (!f.exists()) {
    208                     String dirs = f.getParentFile().getAbsolutePath();
    209                     File parentDir = new File(dirs);
    210                     parentDir.mkdirs();
    211                 }
    212                 f.createNewFile();
    213                 // 将压缩文件内容写入到这个文件中
    214                 InputStream is = zf.getInputStream(entry);
    215                 FileOutputStream fos = new FileOutputStream(f);
    216 
    217                 int count;
    218                 byte[] buf = new byte[8192];
    219                 while ((count = is.read(buf)) != -1) {
    220                     fos.write(buf, 0, count);
    221                 }
    222                 is.close();
    223                 fos.close();
    224             }
    225         }
    226     }
    227 

    转载于:https://www.cnblogs.com/studyskill/p/9832514.html

    展开全文
  • java 压缩与解压文件

    2021-03-30 23:18:57
    /** * @Author: JSONLiu * @Description: Zip操作类 * @Date Created in 2021-03-30 13:54 * @Modified By: */ public class ZipUtil { ... * @param compressPath 压缩文件存放路径 * @return 压缩结果.
  • java 文件zip 压缩与解压 可以直接调用
  • java实现文件压缩与解压是很常见的功能。 我最爱上代码:   1 import java.io.File; 2 import java.util.ArrayList; 3 import java.util.List; 4 5 import net.lingala.zip4j.core.ZipFile; 6...
  • import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.zip.ZipOutputStream; import org.apache.tools.zip.ZipEntry; /** * Z
  • java压缩与解压文件

    2019-09-26 06:53:04
    import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.Fil...
  • Java实现ZIP的解压与压缩功能基本都是使用了Java的多肽和递归技术,可以对单个文件和任意级联文件夹进行压缩解压,对于一些初学者来说是个很不错的实例。 zip扮演着归档和压缩两个角色;gzip并不将文件归档,仅...
  • 安卓端java代码实现对文件压缩与解压
  • 一、压缩文件大致可以分为三种:ZIP、JAR、GZ。 压缩流 在日常中经常会使用到像WinRAR或WinZIP这样的压缩文件,通过这些软件可以把一个很大的文件进行压缩以方便传输。 在JAVA中,为了减少传输时的数据量也提供...
  • 摘要:Java源码,文件操作,GZIP Java使用GZIP压缩解压文件,如果你正在使用Java开发文件压缩或解压的功能,那么Gzip应该来说是比较值得参考的,那么本实例或许正是您需要的,Java基于Gzip的文件压缩与解压程序源代码...
  • java 实现文件压缩与解压,很不错的一个例子,很适合初学者学习
  • Java带密码压缩zip 解压文件源码Java实用源码整理
  • java程序,压缩与解压zip文件.可以压缩带子目录与文件和解压带子目与文件
  • Java中通过ZipOutputStream和ZipInputStream实现对一个或多个文件的压缩与解压。压缩时文件时,创建zip输出流,并在流中添加zip条目,用流把文件的内容写入压缩文件中。解压时,创建zip输入流,并分别创建文件夹和...
  • Java带密码压缩zip与解压文件源码Java实用源码整理learns
  • Java实现文件压缩与解压

    万次阅读 2015-05-08 18:17:00
    在开发过程中,有时需要对用户上传的文件进行一个压缩操作,以节约硬盘空间,那么用Java怎么实现文件压缩与解压呢?很简单,Java为我们提供了一个包,专门负责文件压缩与解压的,那个包就是java.util.zip;   ...
  • Java带密码压缩zip与解压文件源码源码整理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 602
精华内容 240
关键字:

java压缩文件与解压

java 订阅