转： java zip 封装类

/**
 * Here is a program to compress files to *.zip 
 * or uncompress .zip files.
 *
 * @author: zhouych
 *
 * @date: 2008/10/18
 *
 * @since: JDK 1.6
 *
 */
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.util.Vector;
 import java.util.Enumeration;
 import java.util.zip.ZipFile;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;

 public class Zip {
     
    private static final int BUFFER = 1024;    // Length of buffer
    private long length = 0;                // A uncompress directory's length
    
    /**
      * Compress files to *.zip.
      * @param fileName: file to be compress
      */
    public void compress(String fileName) {
        
        String targetFile = null;
        File sourceFile = new File(fileName);
        Vector<File> vector = getAllFiles(sourceFile);
        
        try {
            // NOTE: The zip file's name is according to source file.
             //       And the most important character is '.'. But if
             //       sourceFile is directory, then we give it a name.
             
            if (sourceFile.isDirectory()) {
                /* If source file is a directory */
                targetFile = fileName + ".zip";
            } else {
                char ch = '.';
                 targetFile = fileName.substring(0, fileName.lastIndexOf((int)ch)) + ".zip";
            }
            
            BufferedInputStream bis = null;
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(targetFile));
            ZipOutputStream zipos = new ZipOutputStream(bos);
            byte data[] = new byte[BUFFER];
                        
            for (int i=0; i<vector.size(); i++) {
                File file = (File)vector.get(i);
                zipos.putNextEntry(new ZipEntry(getEntryName(fileName, file)));
                bis = new BufferedInputStream(new FileInputStream(file));
                
                int count;
                while ((count=bis.read(data, 0, BUFFER)) != -1 ) {
                    zipos.write(data, 0, count);
                }
                bis.close();
                zipos.closeEntry();
            }
            
            // NOTE: We can't close the BufferedOutputStream before 
            //       the ZipOutputStream, or it will happened some-
            //       -thing that we don't want to see.
            zipos.close();
            bos.close();
            
            /* Show the compress rate */
            showDetail(sourceFile, new File(targetFile)); 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * Uncompress *.zip files.
     * @param fileName: file to be uncompress
     */
    public void uncompress(String fileName) {
        
        File sourceFile = new File(fileName);
        String filePath = sourceFile.getParent() + "/";
        try {
            BufferedInputStream bis = null;
            BufferedOutputStream bos = null;
            ZipFile zipFile = new ZipFile(fileName);
            Enumeration en = zipFile.entries();
            byte data[] = new byte[BUFFER];
            
            while (en.hasMoreElements()) {
                ZipEntry entry = (ZipEntry)en.nextElement();
                
                if (entry.isDirectory()) {
                    /* Create new directory */
                    new File(filePath + entry.getName()).mkdirs();
                    continue;
                }
                bis = new BufferedInputStream(zipFile.getInputStream(entry));
                File file = new File(filePath + entry.getName());
                // NOTE: ZipFile is random to read the files, so it may
                //       read a file before the file's directory hadn't
                //       been created. So we may create directory first
                File parent = file.getParentFile();
                if (parent!=null && (!parent.exists())) {
                    parent.mkdirs();
                }
                bos = new BufferedOutputStream(new FileOutputStream(file));
                
                int count;
                while ((count=bis.read(data, 0, BUFFER)) != -1) {
                    bos.write(data, 0, count);
                }
                
                bis.close();
                bos.close();
            }
            
            zipFile.close();
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * To get a directory's all files.
     * @param sourceFile: the source directory
     * @return the files' collection
     */
    private Vector<File> getAllFiles(File sourceFile) {
        
        Vector<File> fileVector = new Vector<File>();
        if (sourceFile.isDirectory()) {
            File[] files = sourceFile.listFiles();
            for (int i=0; i<files.length; i++) {
                // NOTE: Here must be use addAll() method.
                fileVector.addAll(getAllFiles(files[i]));
            }
        } else {
            fileVector.add(sourceFile);
        }
        
        return fileVector;
    }
    /**
     *
     */
    //private String getEntryName() {
    //}
    private String getEntryName(String base,File file) {
        File baseFile=new File(base);
        String filename=file.getPath();
        if(baseFile.getParentFile().getParentFile()==null)
            return filename.substring(baseFile.getParent().length());
        return filename.substring(baseFile.getParent().length()+1);
    }
    /**
     * Show the compress or uncompress detail.
     * @param sourceFile: the source file
     * @param targetFile: the target file
     */
    private void showDetail(File sourceFile, File targetFile) {
        
        long sourceFileLength = getDirectoryLength(sourceFile);
        long targetFileLength = targetFile.length();
        System.out.println("The uncompress file's size is " + sourceFileLength + " bytes.");
        System.out.println("The compress file's size is " + targetFileLength + " bytes.");
        System.out.println("The compress rate is " + ((double)(sourceFileLength-targetFileLength)/(double)sourceFileLength)*100 + "%");
    }
    /**
     * Get length of a directory.
     * @param path: the directory
     * @return the length of directory
     */
    private long getDirectoryLength(File path) {
        
        if (path.isDirectory()) {
            File[] files = path.listFiles();
            for (int i=0; i<files.length; i++) {
                getDirectoryLength(files[i]);
            }
        } else {
            // NOTE: The 'length' is define out.
            length += path.length();
        }
        return length;
    }
    
    public static void main(String[] args) {
        
        if (args.length != 2) {
             System.out.println("Usage: java ZipCompress zip/unzip E:/java/apps/zip/text");
             return ;
         }
         Zip zip = new Zip();
         if (args[0].equals("zip")) {
             zip.compress(args[1]);
         } else if(args[0].equals("unzip")) {
             zip.uncompress(args[1]);
         } else {
             System.out.println("Error");
         }
    }
 }