java-a实现压缩与解压缩（zip、gzip）

zip扮演着归档和压缩两个角色；gzip并不将文件归档，仅只是对单个文件进行压缩，所以，在UNIX平台上，命令tar通常用来创建一个档案文件，然后命令gzip来将档案文件压缩。

Java I/O类库还收录了一些能读写压缩格式流的类。要想提供压缩功能，只要把它们包在已有的I/O类的外面就行了。这些类不是Reader和Writer，而是InputStream和OutStreamput的子类。这是因为压缩算法是针对byte而不是字符的。

需要注意的是：java自带的工具类在windows压缩处理编码无法处理中文，所以不建议使用jre

相关类与接口：

Checksum 接口：被类Adler32和CRC32实现的接口
Adler32 ：使用Alder32算法来计算Checksum数目
CRC32 ：使用CRC32算法来计算Checksum数目


CheckedInputStream ：InputStream派生类，可得到输入流的校验和Checksum，用于校验数据的完整性
CheckedOutputStream ：OutputStream派生类，可得到输出流的校验和Checksum， 用于校验数据的完整性


DeflaterOutputStream ：压缩类的基类。 
ZipOutputStream ：DeflaterOutputStream的一个子类，把数据压缩成Zip文件格式。
GZIPOutputStream ：DeflaterOutputStream的一个子类，把数据压缩成GZip文件格式


InflaterInputStream ：解压缩类的基类
ZipInputStream ：InflaterInputStream的一个子类，能解压缩Zip格式的数据
GZIPInputStream ：InflaterInputStream的一个子类，能解压缩Zip格式的数据


ZipEntry 类：表示 ZIP 文件条目
ZipFile 类：此类用于从 ZIP 文件读取条目

压缩类的用法非常简单；只要用GZIPOutputStream 或ZipOutputStream把输出流包起来，再用GZIPInputStream 或ZipInputStream把输入流包起来就行了。剩下的都是些普通的I/O操作。

测试

package com.jre.util.zip;

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.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import com.jre.io.UtilsIoJre;

/**
 * zip文件处理(压缩处理时通过windows系统压缩的由于编码不是utf8的所以将导致中文抛出异常的情况)
 * @author huage
 *
 */
public class UtilsZipJre {

    public static void main(String[] args) {
        zipFileExtract("C:\Users\huage\Desktop\test\111\111.zip","C:\Users\huage\Desktop\test\test");
        //zipDecompressingExtract("C:\Users\huage\Desktop\test\111\111.zip","C:\Users\huage\Desktop\test\test");
        //zipCompressingExtract("C:\Users\huage\Desktop\test\111\test.zip",new File("C:\Users\huage\Desktop\test\test"));

    }
    
    /**
     * 解压
     * @param path
     * @param pathExtract
     */
    public static void zipFileExtract(String path, String pathExtract){
        ZipFile zipfile = null;
        try {
            zipfile = new ZipFile(path);
            Enumeration<ZipEntry> entries = (Enumeration<ZipEntry>)zipfile.entries();
            if( entries!=null ){
                ZipEntry entry ;
                File file;  
                BufferedInputStream bis = null;  
                while( entries.hasMoreElements()){  
                    entry = entries.nextElement();
                    if(entry.isDirectory())continue; 
                    file=new File(pathExtract,entry.getName());  
                    if(!file.exists()){  
                        (new File(file.getParent())).mkdirs();  
                    } 
                    UtilsIoJre.converWriteIO(bis, file);
                    //System.out.println(fout+"解压成功");    
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            UtilsIoJre.closeIO(zipfile);
        }
        
    }
    

    /**
     * zip解压(本地)（官方自带zip解压无法处理中文）
     * 
     * @param path
     *            :zip文件地址
     * @param pathExtract
     *            ：解压地址
     */
    public static void zipDecompressingExtract(String path, String pathExtract) {
        ZipInputStream zipinput = null;
        BufferedInputStream bininput = null;
        try {
            zipinput = new ZipInputStream(new FileInputStream(path));
            bininput = new BufferedInputStream(zipinput);

            
            ZipEntry entry ;
            File fout = null;
            while ((entry = zipinput.getNextEntry()) != null) {
                if(entry.isDirectory())continue; 
                fout=new File(pathExtract,entry.getName());  
                if(!fout.exists()){  
                    (new File(fout.getParent())).mkdirs();  
                } 
                UtilsIoJre.converWriteIO(bininput, fout);
                //System.out.println(fout+"解压成功");    
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            UtilsIoJre.closeIO(bininput,zipinput);
        }
        System.out.println("解压完成");
    }

    /**
     * zip压缩(本地)
     * 
     * @param zipFileName
     * @param inputFile
     * @throws Exception
     */
    public static void zipCompressingExtract(String zipFileName, File inputFile) {
        ZipOutputStream out = null;
        BufferedOutputStream bo = null;
        try {
            out = new ZipOutputStream(new FileOutputStream(zipFileName));
            bo = new BufferedOutputStream(out);
            zipCompressing(out, inputFile, bo);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            UtilsIoJre.closeIO(bo,out);
        }
        System.out.println("压缩完成");
    }

    /**
     * zip压缩
     * 
     * @param out
     * @param file
     * @param base
     * @param bo
     * @throws Exception
     */
    private static void zipCompressing(ZipOutputStream out, File file, BufferedOutputStream bo) throws Exception {
        if (file.isDirectory()) {
            File[] fl = file.listFiles();
            if (fl.length == 0) {
                out.putNextEntry(new ZipEntry(file.getName()));
            }
            for (int i = 0; i < fl.length; i++) {
                zipCompressing(out, fl[i], bo);
            }
        } else {
            out.putNextEntry(new ZipEntry(file.getName() ));
            UtilsIoJre.converReadIO(bo, file);
        }
    }
}


package com.jre.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * io流处理
 * @author huage
 *
 */
public class UtilsIoJre {

    /**
     * 将file写入BufferedOutputStream中
     * @param bo
     * @param file
     * @throws Exception
     */
    public static void converReadIO(BufferedOutputStream bo,File file) throws Exception{
        FileInputStream in = new FileInputStream(file);
        BufferedInputStream bi = new BufferedInputStream(in);
        int b;
        while ((b = in.read()) != -1) {
            bo.write(b);
        }
        closeIO(bi,in);
        bo.flush();//清空缓存
    }
    
    /**
     * 将BufferedInputStream写入file中
     * @param bo
     * @param file
     * @throws Exception
     */
    public static void converWriteIO(BufferedInputStream bininput,File file) throws Exception{
        FileOutputStream out = new FileOutputStream(file);
        BufferedOutputStream bout = new BufferedOutputStream(out);
        int b;
        while ((b = bininput.read()) != -1) {
            bout.write(b);
        }
        closeIO(bout,out);
        bout.flush();//清空缓存
    }
    
    
    /**
     * 关闭io
     * @param cl
     */
    public static void closeIO(AutoCloseable... cl){
        if( cl == null || cl.length == 0 )return;
        for (AutoCloseable c : cl) {
            try {
                c.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}