用java实现zip压缩和解压缩功能。

 本文使用了jdk1.5.0_13的源代码。(java.uti.zip*)

实现方法：首先将java.uti.zip中的源代码解压出来。找到DeflaterOutputStream、InflaterInputStream、ZipConstants、ZipEntry、ZipInputStream、ZipOutputStream，放到新的包com.work.util.zip中，重新组织这些文件的import，能使用当前包中类的就使用当前包中的类。

重点要修改的类：ZipEntry，修改内容如下：

1. //修改对应的程序，在这里加载zip库
2.     static {
3.         /* load the zip library */
4.         java.security.AccessController
5.                 .doPrivileged(new sun.security.action.LoadLibraryAction("zip"));
6. //      initIDs();
7.     }
8. //  static {
9. //      /* Zip library is loaded from System.initializeSystemClass */
10. //      initIDs();
11. //  }
13. //  private static native void initIDs();

其次修改ZipInputStream，大约在279行。

1. // ZipEntry e = createZipEntry(getUTF8String(b, 0, len));
2.         ZipEntry e = null;
3.         try {
4.             if (this.encoding.toUpperCase().equals("UTF-8"))
5.                 e = createZipEntry(getUTF8String(b, 0, len));
6.             else
7.                 e = createZipEntry(new String(b, 0, len, this.encoding));
8.         } catch (Exception byteE) {
9.             e = createZipEntry(getUTF8String(b, 0, len));
10.         }
11. //增加构造方法
12. private String encoding = "UTF-8";
13.  public ZipInputStream(InputStream in, String encoding) {
      super(new PushbackInputStream(in, 512), new Inflater(true), 512);
      usesDefaultInflater = true;
      if (in == null) {
       throw new NullPointerException("in is null");
      }
      this.encoding = encoding;
     }

再次修改ZipOutputStream类，源代码如下：

1. /*
2.  * @(#)ZipOutputStream.java 1.31 03/12/19
3.  *
4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6.  */
8. package com.work.util.zip;
10. import java.io.IOException;
11. import java.io.OutputStream;
12. import java.util.Enumeration;
13. import java.util.Hashtable;
14. import java.util.Vector;
15. import java.util.zip.CRC32;
16. import java.util.zip.Deflater;
17. import java.util.zip.ZipException;
19. /**
20.  * This class implements an output stream filter for writing files in the ZIP
21.  * file format. Includes support for both compressed and uncompressed entries.
22.  * 
23.  * @author David Connelly
24.  * @version 1.31, 12/19/03
25.  */
26. public class ZipOutputStream extends DeflaterOutputStream implements
27.         ZipConstants {
28.     private ZipEntry entry;
29.     private Vector entries = new Vector();
30.     private Hashtable names = new Hashtable();
31.     private CRC32 crc = new CRC32();
32.     private long written = 0;
33.     private long locoff = 0;
34.     private String comment;
35.     private int method = DEFLATED;
36.     private boolean finished;
38.     private boolean closed = false;
40.     /**
41.      * Check to make sure that this stream has not been closed
42.      */
43.     private void ensureOpen() throws IOException {
44.         if (closed) {
45.             throw new IOException("Stream closed");
46.         }
47.     }
49.     /**
50.      * Compression method for uncompressed (STORED) entries.
51.      */
52.     public static final int STORED = ZipEntry.STORED;
54.     /**
55.      * Compression method for compressed (DEFLATED) entries.
56.      */
57.     public static final int DEFLATED = ZipEntry.DEFLATED;
59.     private String encoding = "UTF-8";
61.     public ZipOutputStream(OutputStream out, String encoding) {
62.         super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
63.         usesDefaultDeflater = true;
64.         this.encoding = encoding;
65.     }
67.     /**
68.      * Creates a new ZIP output stream.
69.      * 
70.      * @param out
71.      *            the actual output stream
72.      */
73.     public ZipOutputStream(OutputStream out) {
74.         super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
75.         usesDefaultDeflater = true;
76.     }
78.     /**
79.      * Sets the ZIP file comment.
80.      * 
81.      * @param comment
82.      *            the comment string
83.      * @exception IllegalArgumentException
84.      *                if the length of the specified ZIP file comment is greater
85.      *                than 0xFFFF bytes
86.      */
87.     public void setComment(String comment) {
88.         if (comment != null && comment.length() > 0xffff / 3
89.                 && getUTF8Length(comment) > 0xffff) {
90.             throw new IllegalArgumentException("ZIP file comment too long.");
91.         }
92.         this.comment = comment;
93.     }
95.     /**
96.      * Sets the default compression method for subsequent entries. This default
97.      * will be used whenever the compression method is not specified for an
98.      * individual ZIP file entry, and is initially set to DEFLATED.
99.      * 
100.      * @param method
101.      *            the default compression method
102.      * @exception IllegalArgumentException
103.      *                if the specified compression method is invalid
104.      */
105.     public void setMethod(int method) {
106.         if (method != DEFLATED && method != STORED) {
107.             throw new IllegalArgumentException("invalid compression method");
108.         }
109.         this.method = method;
110.     }
112.     /**
113.      * Sets the compression level for subsequent entries which are DEFLATED. The
114.      * default setting is DEFAULT_COMPRESSION.
115.      * 
116.      * @param level
117.      *            the compression level (0-9)
118.      * @exception IllegalArgumentException
119.      *                if the compression level is invalid
120.      */
121.     public void setLevel(int level) {
122.         def.setLevel(level);
123.     }
125.     /**
126.      * Begins writing a new ZIP file entry and positions the stream to the start
127.      * of the entry data. Closes the current entry if still active. The default
128.      * compression method will be used if no compression method was specified
129.      * for the entry, and the current time will be used if the entry has no set
130.      * modification time.
131.      * 
132.      * @param e
133.      *            the ZIP entry to be written
134.      * @exception ZipException
135.      *                if a ZIP format error has occurred
136.      * @exception IOException
137.      *                if an I/O error has occurred
138.      */
139.     public void putNextEntry(ZipEntry e) throws IOException {
140.         ensureOpen();
141.         if (entry != null) {
142.             closeEntry(); // close previous entry
143.         }
144.         if (e.time == -1) {
145.             e.setTime(System.currentTimeMillis());
146.         }
147.         if (e.method == -1) {
148.             e.method = method; // use default method
149.         }
150.         switch (e.method) {
151.         case DEFLATED:
152.             if (e.size == -1 || e.csize == -1 || e.crc == -1) {
153.                 // store size, compressed size, and crc-32 in data descriptor
154.                 // immediately following the compressed entry data
155.                 e.flag = 8;
156.             } else if (e.size != -1 && e.csize != -1 && e.crc != -1) {
157.                 // store size, compressed size, and crc-32 in LOC header
158.                 e.flag = 0;
159.             } else {
160.                 throw new ZipException(
161.                         "DEFLATED entry missing size, compressed size, or crc-32");
162.             }
163.             e.version = 20;
164.             break;
165.         case STORED:
166.             // compressed size, uncompressed size, and crc-32 must all be
167.             // set for entries using STORED compression method
168.             if (e.size == -1) {
169.                 e.size = e.csize;
170.             } else if (e.csize == -1) {
171.                 e.csize = e.size;
172.             } else if (e.size != e.csize) {
173.                 throw new ZipException(
174.                         "STORED entry where compressed != uncompressed size");
175.             }
176.             if (e.size == -1 || e.crc == -1) {
177.                 throw new ZipException(
178.                         "STORED entry missing size, compressed size, or crc-32");
179.             }
180.             e.version = 10;
181.             e.flag = 0;
182.             break;
183.         default:
184.             throw new ZipException("unsupported compression method");
185.         }
186.         e.offset = written;
187.         if (names.put(e.name, e) != null) {
188.             throw new ZipException("duplicate entry: " + e.name);
189.         }
190.         writeLOC(e);
191.         entries.addElement(e);
192.         entry = e;
193.     }
195.     /**
196.      * Closes the current ZIP entry and positions the stream for writing the
197.      * next entry.
198.      * 
199.      * @exception ZipException
200.      *                if a ZIP format error has occurred
201.      * @exception IOException
202.      *                if an I/O error has occurred
203.      */
204.     public void closeEntry() throws IOException {
205.         ensureOpen();
206.         ZipEntry e = entry;
207.         if (e != null) {
208.             switch (e.method) {
209.             case DEFLATED:
210.                 def.finish();
211.                 while (!def.finished()) {
212.                     deflate();
213.                 }
214.                 if ((e.flag & 8) == 0) {
215.                     // verify size, compressed size, and crc-32 settings
216.                     if (e.size != def.getBytesRead()) {
217.                         throw new ZipException("invalid entry size (expected "
218.                                 + e.size + " but got " + def.getBytesRead()
219.                                 + " bytes)");
220.                     }
221.                     if (e.csize != def.getBytesWritten()) {
222.                         throw new ZipException(
223.                                 "invalid entry compressed size (expected "
224.                                         + e.csize + " but got "
225.                                         + def.getBytesWritten() + " bytes)");
226.                     }
227.                     if (e.crc != crc.getValue()) {
228.                         throw new ZipException(
229.                                 "invalid entry CRC-32 (expected 0x"
230.                                         + Long.toHexString(e.crc)
231.                                         + " but got 0x"
232.                                         + Long.toHexString(crc.getValue())
233.                                         + ")");
234.                     }
235.                 } else {
236.                     e.size = def.getBytesRead();
237.                     e.csize = def.getBytesWritten();
238.                     e.crc = crc.getValue();
239.                     writeEXT(e);
240.                 }
241.                 def.reset();
242.                 written += e.csize;
243.                 break;
244.             case STORED:
245.                 // we already know that both e.size and e.csize are the same
246.                 if (e.size != written - locoff) {
247.                     throw new ZipException("invalid entry size (expected "
248.                             + e.size + " but got " + (written - locoff)
249.                             + " bytes)");
250.                 }
251.                 if (e.crc != crc.getValue()) {
252.                     throw new ZipException("invalid entry crc-32 (expected 0x"
253.                             + Long.toHexString(e.crc) + " but got 0x"
254.                             + Long.toHexString(crc.getValue()) + ")");
255.                 }
256.                 break;
257.             default:
258.                 throw new InternalError("invalid compression method");
259.             }
260.             crc.reset();
261.             entry = null;
262.         }
263.     }
265.     /**
266.      * Writes an array of bytes to the current ZIP entry data. This method will
267.      * block until all the bytes are written.
268.      * 
269.      * @param b
270.      *            the data to be written
271.      * @param off
272.      *            the start offset in the data
273.      * @param len
274.      *            the number of bytes that are written
275.      * @exception ZipException
276.      *                if a ZIP file error has occurred
277.      * @exception IOException
278.      *                if an I/O error has occurred
279.      */
280.     public synchronized void write(byte[] b, int off, int len)
281.             throws IOException {
282.         ensureOpen();
283.         if (off < 0 || len < 0 || off > b.length - len) {
284.             throw new IndexOutOfBoundsException();
285.         } else if (len == 0) {
286.             return;
287.         }
289.         if (entry == null) {
290.             throw new ZipException("no current ZIP entry");
291.         }
292.         switch (entry.method) {
293.         case DEFLATED:
294.             super.write(b, off, len);
295.             break;
296.         case STORED:
297.             written += len;
298.             if (written - locoff > entry.size) {
299.                 throw new ZipException(
300.                         "attempt to write past end of STORED entry");
301.             }
302.             out.write(b, off, len);
303.             break;
304.         default:
305.             throw new InternalError("invalid compression method");
306.         }
307.         crc.update(b, off, len);
308.     }
310.     /**
311.      * Finishes writing the contents of the ZIP output stream without closing
312.      * the underlying stream. Use this method when applying multiple filters in
313.      * succession to the same output stream.
314.      * 
315.      * @exception ZipException
316.      *                if a ZIP file error has occurred
317.      * @exception IOException
318.      *                if an I/O exception has occurred
319.      */
320.     public void finish() throws IOException {
321.         ensureOpen();
322.         if (finished) {
323.             return;
324.         }
325.         if (entry != null) {
326.             closeEntry();
327.         }
328.         if (entries.size() < 1) {
329.             throw new ZipException("ZIP file must have at least one entry");
330.         }
331.         // write central directory
332.         long off = written;
333.         Enumeration e = entries.elements();
334.         while (e.hasMoreElements()) {
335.             writeCEN((ZipEntry) e.nextElement());
336.         }
337.         writeEND(off, written - off);
338.         finished = true;
339.     }
341.     /**
342.      * Closes the ZIP output stream as well as the stream being filtered.
343.      * 
344.      * @exception ZipException
345.      *                if a ZIP file error has occurred
346.      * @exception IOException
347.      *                if an I/O error has occurred
348.      */
349.     public void close() throws IOException {
350.         if (!closed) {
351.             super.close();
352.             closed = true;
353.         }
354.     }
356.     /*
357.      * Writes local file (LOC) header for specified entry.
358.      */
359.     private void writeLOC(ZipEntry e) throws IOException {
360.         writeInt(LOCSIG); // LOC header signature
361.         writeShort(e.version); // version needed to extract
362.         writeShort(e.flag); // general purpose bit flag
363.         writeShort(e.method); // compression method
364.         writeInt(e.time); // last modification time
365.         if ((e.flag & 8) == 8) {
366.             // store size, uncompressed size, and crc-32 in data descriptor
367.             // immediately following compressed entry data
368.             writeInt(0);
369.             writeInt(0);
370.             writeInt(0);
371.         } else {
372.             writeInt(e.crc); // crc-32
373.             writeInt(e.csize); // compressed size
374.             writeInt(e.size); // uncompressed size
375.         }
376.         // byte[] nameBytes = getUTF8Bytes(e.name);
377.         byte[] nameBytes = null;
378.         try {
379.             if (this.encoding.toUpperCase().equals("UTF-8"))
380.                 nameBytes = getUTF8Bytes(e.name);
381.             else
382.                 nameBytes = e.name.getBytes(this.encoding);
383.         } catch (Exception byteE) {
384.             nameBytes = getUTF8Bytes(e.name);
385.         }
387.         writeShort(nameBytes.length);
388.         writeShort(e.extra != null ? e.extra.length : 0);
389.         writeBytes(nameBytes, 0, nameBytes.length);
390.         if (e.extra != null) {
391.             writeBytes(e.extra, 0, e.extra.length);
392.         }
393.         locoff = written;
394.     }
396.     /*
397.      * Writes extra data descriptor (EXT) for specified entry.
398.      */
399.     private void writeEXT(ZipEntry e) throws IOException {
400.         writeInt(EXTSIG); // EXT header signature
401.         writeInt(e.crc); // crc-32
402.         writeInt(e.csize); // compressed size
403.         writeInt(e.size); // uncompressed size
404.     }
406.     /*
407.      * Write central directory (CEN) header for specified entry. REMIND: add
408.      * support for file attributes
409.      */
410.     private void writeCEN(ZipEntry e) throws IOException {
411.         writeInt(CENSIG); // CEN header signature
412.         writeShort(e.version); // version made by
413.         writeShort(e.version); // version needed to extract
414.         writeShort(e.flag); // general purpose bit flag
415.         writeShort(e.method); // compression method
416.         writeInt(e.time); // last modification time
417.         writeInt(e.crc); // crc-32
418.         writeInt(e.csize); // compressed size
419.         writeInt(e.size); // uncompressed size
420.         // byte[] nameBytes = getUTF8Bytes(e.name);
421.         byte[] nameBytes = null;
422.         try {
423.             if (this.encoding.toUpperCase().equals("UTF-8"))
424.                 nameBytes = getUTF8Bytes(e.name);
425.             else
426.                 nameBytes = e.name.getBytes(this.encoding);
427.         } catch (Exception byteE) {
428.             nameBytes = getUTF8Bytes(e.name);
429.         }
430.         writeShort(nameBytes.length);
431.         writeShort(e.extra != null ? e.extra.length : 0);
432.         byte[] commentBytes;
433.         if (e.comment != null) {
434.             
435.             //commentBytes = getUTF8Bytes(e.comment);
436.             
437.             try {
438.                 if (this.encoding.toUpperCase().equals("UTF-8"))
439.                     commentBytes = getUTF8Bytes(e.comment);
440.                 else
441.                     commentBytes = e.comment.getBytes(this.encoding);
442.             } catch (Exception byteE) {
443.                 commentBytes = getUTF8Bytes(e.comment);
444.             }           
445.             
446.             writeShort(commentBytes.length);
447.         } else {
448.             commentBytes = null;
449.             writeShort(0);
450.         }
451.         writeShort(0); // starting disk number
452.         writeShort(0); // internal file attributes (unused)
453.         writeInt(0); // external file attributes (unused)
454.         writeInt(e.offset); // relative offset of local header
455.         writeBytes(nameBytes, 0, nameBytes.length);
456.         if (e.extra != null) {
457.             writeBytes(e.extra, 0, e.extra.length);
458.         }
459.         if (commentBytes != null) {
460.             writeBytes(commentBytes, 0, commentBytes.length);
461.         }
462.     }
464.     /*
465.      * Writes end of central directory (END) header.
466.      */
467.     private void writeEND(long off, long len) throws IOException {
468.         writeInt(ENDSIG); // END record signature
469.         writeShort(0); // number of this disk
470.         writeShort(0); // central directory start disk
471.         writeShort(entries.size()); // number of directory entries on disk
472.         writeShort(entries.size()); // total number of directory entries
473.         writeInt(len); // length of central directory
474.         writeInt(off); // offset of central directory
475.         if (comment != null) { // zip file comment
476.             //byte[] b = getUTF8Bytes(comment);
477.             byte[] b = null;
478.             
479.             try {
480.                 if (this.encoding.toUpperCase().equals("UTF-8"))
481.                     b = getUTF8Bytes(comment);
482.                 else
483.                     b = comment.getBytes(this.encoding);
484.             } catch (Exception byteE) {
485.                 b = getUTF8Bytes(comment);
486.             }               
487.             writeShort(b.length);
488.             writeBytes(b, 0, b.length);
489.         } else {
490.             writeShort(0);
491.         }
492.     }
494.     /*
495.      * Writes a 16-bit short to the output stream in little-endian byte order.
496.      */
497.     private void writeShort(int v) throws IOException {
498.         OutputStream out = this.out;
499.         out.write((v >>> 0) & 0xff);
500.         out.write((v >>> 8) & 0xff);
501.         written += 2;
502.     }
504.     /*
505.      * Writes a 32-bit int to the output stream in little-endian byte order.
506.      */
507.     private void writeInt(long v) throws IOException {
508.         OutputStream out = this.out;
509.         out.write((int) ((v >>> 0) & 0xff));
510.         out.write((int) ((v >>> 8) & 0xff));
511.         out.write((int) ((v >>> 16) & 0xff));
512.         out.write((int) ((v >>> 24) & 0xff));
513.         written += 4;
514.     }
516.     /*
517.      * Writes an array of bytes to the output stream.
518.      */
519.     private void writeBytes(byte[] b, int off, int len) throws IOException {
520.         super.out.write(b, off, len);
521.         written += len;
522.     }
524.     /*
525.      * Returns the length of String's UTF8 encoding.
526.      */
527.     static int getUTF8Length(String s) {
528.         int count = 0;
529.         for (int i = 0; i < s.length(); i++) {
530.             char ch = s.charAt(i);
531.             if (ch <= 0x7f) {
532.                 count++;
533.             } else if (ch <= 0x7ff) {
534.                 count += 2;
535.             } else {
536.                 count += 3;
537.             }
538.         }
539.         return count;
540.     }
542.     /*
543.      * Returns an array of bytes representing the UTF8 encoding of the specified
544.      * String.
545.      */
546.     private static byte[] getUTF8Bytes(String s) {
547.         char[] c = s.toCharArray();
548.         int len = c.length;
549.         // Count the number of encoded bytes...
550.         int count = 0;
551.         for (int i = 0; i < len; i++) {
552.             int ch = c[i];
553.             if (ch <= 0x7f) {
554.                 count++;
555.             } else if (ch <= 0x7ff) {
556.                 count += 2;
557.             } else {
558.                 count += 3;
559.             }
560.         }
561.         // Now return the encoded bytes...
562.         byte[] b = new byte[count];
563.         int off = 0;
564.         for (int i = 0; i < len; i++) {
565.             int ch = c[i];
566.             if (ch <= 0x7f) {
567.                 b[off++] = (byte) ch;
568.             } else if (ch <= 0x7ff) {
569.                 b[off++] = (byte) ((ch >> 6) | 0xc0);
570.                 b[off++] = (byte) ((ch & 0x3f) | 0x80);
571.             } else {
572.                 b[off++] = (byte) ((ch >> 12) | 0xe0);
573.                 b[off++] = (byte) (((ch >> 6) & 0x3f) | 0x80);
574.                 b[off++] = (byte) ((ch & 0x3f) | 0x80);
575.             }
576.         }
577.         return b;
578.     }
579. }

剩下的工作就是编写压缩和解压缩的功能类了ZipUtil.java

 

1. package com.work.util;
3. import java.io.BufferedInputStream;
4. import java.io.BufferedOutputStream;
5. import java.io.File;
6. import java.io.FileInputStream;
7. import java.io.FileNotFoundException;
8. import java.io.FileOutputStream;
9. import java.io.IOException;
10. import java.io.InputStream;
12. import org.apache.commons.logging.Log;
13. import org.apache.commons.logging.LogFactory;
15. import com.work.util.zip.ZipInputStream;
16. import com.work.util.zip.ZipOutputStream;
17. import com.work.util.zip.ZipEntry;
19. /**
20.  * @project proxool-0.9.1 中的java.util.zip包和此类联合使用
21.  * @author wangmingjie
22.  * 
23.  */
24. public class ZipUtil {
25.     private static Log log = LogFactory.getLog(ZipUtil.class);
27.     /**
28.      * 解压缩文件夹。
29.      * 
30.      * @param srcFilename
31.      * @param destFilename
32.      * @param overwrite
33.      * @throws IOException
34.      */
35.     public void unzipDir(String srcFilename,boolean overwrite) throws IOException {
37.         File srcFile = new File(srcFilename);
38.         // 首先判断源文件是否存在
39.         if (!srcFile.exists()) {
40.             throw new FileNotFoundException("Cannot find the source file: "
41.                     + srcFile.getAbsolutePath());
42.         }
43.         // 判断源文件是否可读
44.         if (!srcFile.canRead()) {
45.             throw new IOException("Cannot read the source file: "
46.                     + srcFile.getAbsolutePath());
47.         }
49.         FileInputStream fin = null;
50.         BufferedInputStream inputStream = null;
51.         ZipInputStream zipInputStream = null;
52.         try {
53.             fin = new FileInputStream(srcFile);
54.             inputStream = new BufferedInputStream(fin);
55.             zipInputStream = new ZipInputStream(inputStream, "gbk");//在这里设置编码格式，解决文件名和备注乱码问题
56.             ZipEntry zipEntry = null;
57.             String tempFileName = null;
58.             while ((zipEntry = zipInputStream.getNextEntry()) != null) {
59.                 
60.                 tempFileName = zipEntry.getName();
61.                 if (zipEntry.isDirectory()) {
62.                     // 创建文件夹
63.                     FileUtil.createDirs(tempFileName, true);
64.                 } else {
65.                     tempFileName = tempFileName.replace("//", "/");
66.                     //System.out.println("文件夹=" + tempFileName.substring(0,tempFileName.lastIndexOf("/")));
67.                     FileUtil.createDirs(tempFileName.substring(0,tempFileName.lastIndexOf("/")), true);
68.                     //System.out.println("tempFileName=" + tempFileName);
69.                     unzipFile(zipInputStream, tempFileName); // 解压缩
70.                 }
71.                 zipInputStream.closeEntry();//关闭当前 ZIP 条目并定位流以读取下一个条目。
72.                 //不写上面的一句，程序也能够正常运行。
73.             }
74.             
76.         } finally {
77.             if (zipInputStream != null) {
78.                 try {
79.                     zipInputStream.close();
80.                 } catch (IOException ex) {
81.                     // just ignore
82.                 }
83.             }
85.             if (inputStream != null) {
86.                 try {
87.                     inputStream.close();
88.                 } catch (IOException ex) {
89.                     // just ignore
90.                 }
91.             }
92.             if (fin != null) {
93.                 try {
94.                     fin.close();
95.                 } catch (IOException ex) {
96.                     // just ignore
97.                 }
98.             }
100.         }
101.     }
103.     /**
104.      * 创建解压缩的文件
105.      * 
106.      * @param srcFilename
107.      * @param zipInputStream
108.      * @throws IOException
109.      */
110.     private void unzipFile(InputStream zipInputStream, String destFileName)
111.             throws IOException {
113.         FileOutputStream fout = null;
114.         BufferedOutputStream outputStream = null;
116.         byte[] block = new byte[1024];
117.         try {
118.             if(log.isDebugEnabled()){
119.                 log.debug("要生成的文件名称为：" + destFileName);
120.             }
121.             
122.             File destFile = new File(destFileName);
124.             // 如果要覆盖已经存在的目标文件，首先判断是否目标文件可写。
125.             if (destFile.exists()) {
126.                 if (!destFile.canWrite()) {
127.                     throw new IOException("Cannot write the destination file: "
128.                             + destFile.getAbsolutePath());
129.                 }
130.             } else {
131.                 // 不存在就创建一个新的空文件。
132.                 if (!destFile.createNewFile()) {
133.                     throw new IOException("Cannot write the destination file: "
134.                             + destFile.getAbsolutePath());
135.                 }
136.             }
137.             fout = new FileOutputStream(destFile);
138.             outputStream = new BufferedOutputStream(fout);
139.             // 开始从zip文件中读取数据
140.             while (true) {
141.                 int readLength = zipInputStream.read(block);
143.                 if (readLength == -1)
144.                     break;// end of file
145.                 outputStream.write(block, 0, readLength);
146.             }
147.             outputStream.flush();
149.         } finally {
151.             if (outputStream != null) {
152.                 try {
153.                     outputStream.close();
154.                 } catch (IOException ex) {
155.                     // just ignore
156.                 }
157.             }
158.             if (fout != null) {
159.                 try {
160.                     fout.close();
161.                 } catch (IOException ex) {
162.                     // just ignore
163.                 }
164.             }
166.         }
167.     }
169.     /**
170.      * 解压缩单个文件。程序测试的过度函数！
171.      * 
172.      * @param srcFilename
173.      * @param destFilename
174.      * @param overwrite
175.      * @throws IOException
176.      */
177.     public void unzipFile(String srcFilename, String destFilename,
178.             boolean overwrite) throws IOException {
180.         File srcFile = new File(srcFilename);
181.         // 首先判断源文件是否存在
182.         if (!srcFile.exists()) {
183.             throw new FileNotFoundException("Cannot find the source file: "
184.                     + srcFile.getAbsolutePath());
185.         }
186.         // 判断源文件是否可读
187.         if (!srcFile.canRead()) {
188.             throw new IOException("Cannot read the source file: "
189.                     + srcFile.getAbsolutePath());
190.         }
192.         FileInputStream fin = null;
193.         BufferedInputStream inputStream = null;
194.         ZipInputStream zipInputStream = null;
196.         FileOutputStream fout = null;
197.         BufferedOutputStream outputStream = null;
199.         byte[] block = new byte[1024];
200.         try {
201.             fin = new FileInputStream(srcFile);
202.             inputStream = new BufferedInputStream(fin);
203.             zipInputStream = new ZipInputStream(inputStream, "gbk");
205.             ZipEntry zipEntry = zipInputStream.getNextEntry();
207.             if (destFilename == null || destFilename.trim().equals("")) {
208.                 destFilename = zipEntry.getName();
209.             }
211.             System.out.println("解压缩生成的文件名称为：" + destFilename);
212.             File destFile = new File(destFilename);
214.             if (overwrite == false) {
215.                 // 目标文件存在就不覆盖
216.                 if (destFile.exists())
217.                     return;
218.             } else {
219.                 // 如果要覆盖已经存在的目标文件，首先判断是否目标文件可写。
220.                 if (destFile.exists()) {
221.                     if (!destFile.canWrite()) {
222.                         throw new IOException(
223.                                 "Cannot write the destination file: "
224.                                         + destFile.getAbsolutePath());
225.                     }
226.                 } else {
227.                     // 不存在就创建一个新的空文件。
228.                     if (!destFile.createNewFile()) {
229.                         throw new IOException(
230.                                 "Cannot write the destination file: "
231.                                         + destFile.getAbsolutePath());
232.                     }
233.                 }
234.             }
235.             fout = new FileOutputStream(destFile);
236.             outputStream = new BufferedOutputStream(fout);
237.             // 开始从zip文件中读取数据
238.             while (true) {
239.                 int readLength = zipInputStream.read(block);
240.                 if (readLength == -1)
241.                     break;// end of file
242.                 outputStream.write(block, 0, readLength);
243.             }
244.             outputStream.flush();
245.         } finally {
246.             if (zipInputStream != null) {
247.                 try {
248.                     zipInputStream.close();
249.                 } catch (IOException ex) {
250.                     // just ignore
251.                 }
252.             }
254.             if (inputStream != null) {
255.                 try {
256.                     inputStream.close();
257.                 } catch (IOException ex) {
258.                     // just ignore
259.                 }
260.             }
261.             if (fin != null) {
262.                 try {
263.                     fin.close();
264.                 } catch (IOException ex) {
265.                     // just ignore
266.                 }
267.             }
269.             if (outputStream != null) {
270.                 try {
271.                     outputStream.close();
272.                 } catch (IOException ex) {
273.                     // just ignore
274.                 }
275.             }
276.             if (fout != null) {
277.                 try {
278.                     fout.close();
279.                 } catch (IOException ex) {
280.                     // just ignore
281.                 }
282.             }
284.         }
285.     }
287.     /**
288.      * 压缩单个文件。
289.      * 
290.      * @param srcFilename
291.      * @param destFilename
292.      * @param overwrite
293.      * @throws IOException
294.      */
295.     /**
296.      * @param srcFilename
297.      * @param destDir  目标文件保存在哪个文件夹下面
298.      * @param destFilename
299.      * @param overwrite
300.      * @throws IOException
301.      */
302.     public void zipFile(String srcFilename, String destDir,String destFilename,
303.             boolean overwrite) throws IOException {
305.         File srcFile = new File(srcFilename);
306.         // 首先判断源文件是否存在
307.         if (!srcFile.exists()) {
308.             throw new FileNotFoundException("Cannot find the source file: "
309.                     + srcFile.getAbsolutePath());
310.         }
311.         // 判断源文件是否可读
312.         if (!srcFile.canRead()) {
313.             throw new IOException("Cannot read the source file: "
314.                     + srcFile.getAbsolutePath());
315.         }
317.         if (destFilename == null || destFilename.trim().equals("")) {
318.             destFilename = srcFilename + ".zip";
319.         } else {
320.             destFilename += ".zip";
321.         }
322.         destDir = (destDir.endsWith("/") || destDir.endsWith("//"))?destDir.substring(0,destDir.length()-1):destDir;
323.         
324.         File destFile = new File(destDir+"/"+destFilename);
326.         if (overwrite == false) {
327.             // 目标文件存在就不覆盖
328.             if (destFile.exists())
329.                 return;
330.         } else {
331.             // 如果要覆盖已经存在的目标文件，首先判断是否目标文件可写。
332.             if (destFile.exists()) {
333.                 if (!destFile.canWrite()) {
334.                     throw new IOException("Cannot write the destination file: "
335.                             + destFile.getAbsolutePath());
336.                 }
337.             } else {
338.                 // 不存在就创建一个新的空文件。
339.                 if (!destFile.createNewFile()) {
340.                     throw new IOException("Cannot write the destination file: "
341.                             + destFile.getAbsolutePath());
342.                 }
343.             }
344.         }
345.         FileInputStream fin = null;
346.         BufferedInputStream inputStream = null;
348.         FileOutputStream fout = new FileOutputStream(destFile);
349.         BufferedOutputStream outputStream = null;
350.         ZipOutputStream zipOutputStream = null;
351.         byte[] block = new byte[1024];
352.         try {
353.             fin = new FileInputStream(srcFile);
354.             inputStream = new BufferedInputStream(fin);
355.             outputStream = new BufferedOutputStream(fout);
356.             zipOutputStream = new ZipOutputStream(outputStream, "gbk");
358.             zipOutputStream.setComment("通过java程序压缩的,压缩时间为:"+DateUtil.getCurrentDateTime());
359.             ZipEntry zipEntry = new ZipEntry(srcFile.getName());
360.             zipEntry.setComment(" zipEntry通过java程序压缩的");
361.             zipOutputStream.putNextEntry(zipEntry);
362.             while (true) {
363.                 int readLength = inputStream.read(block);
364.                 if (readLength == -1)
365.                     break;// end of file
366.                 zipOutputStream.write(block, 0, readLength);
367.             }
368.             zipOutputStream.flush();
369.             zipOutputStream.finish();
370.         } finally {
371.             if (inputStream != null) {
372.                 try {
373.                     inputStream.close();
374.                 } catch (IOException ex) {
375.                     // just ignore
376.                 }
377.             }
378.             if (fin != null) {
379.                 try {
380.                     fin.close();
381.                 } catch (IOException ex) {
382.                     // just ignore
383.                 }
384.             }
385.             if (zipOutputStream != null) {
386.                 try {
387.                     zipOutputStream.close();
388.                 } catch (IOException ex) {
389.                     // just ignore
390.                 }
391.             }
392.             if (outputStream != null) {
393.                 try {
394.                     outputStream.close();
395.                 } catch (IOException ex) {
396.                     // just ignore
397.                 }
398.             }
399.             if (fout != null) {
400.                 try {
401.                     fout.close();
402.                 } catch (IOException ex) {
403.                     // just ignore
404.                 }
405.             }
407.         }
408.     }
410.     /**
411.      * 
412.      * @param srcFilename
413.      *            源文件
414.      * @param destFilename
415.      *            目标文件名称，如果为空，那么就使用源文件的名称+.zip作为文件名
416.      * @param overwrite
417.      *            如果目标文件存在是否覆盖源文件，默认是不覆盖。
418.      * @throws IOException
419.      */
420.     public void zipDir(String srcFilename, String destFilename,
421.             boolean overwrite) throws IOException {
422.         File srcFile = new File(srcFilename);
423.         // 首先判断源文件是否存在
424.         if (!srcFile.exists()) {
425.             throw new FileNotFoundException("Cannot find the source file: "
426.                     + srcFile.getAbsolutePath());
427.         }
428.         // 判断源文件是否可读
429.         if (!srcFile.canRead()) {
430.             throw new IOException("Cannot read the source file: "
431.                     + srcFile.getAbsolutePath());
432.         }
434.         if (destFilename == null || destFilename.trim().equals("")) {
435.             destFilename = srcFilename + ".zip";
436.         } else {
437.             destFilename += ".zip";
438.         }
439.         File destFile = new File(destFilename);
441.         if (overwrite == false) {
442.             // 目标文件存在就不覆盖
443.             if (destFile.exists())
444.                 return;
445.         } else {
446.             // 如果要覆盖已经存在的目标文件，首先判断是否目标文件可写。
447.             if (destFile.exists()) {
448.                 if (!destFile.canWrite()) {
449.                     throw new IOException("Cannot write the destination file: "
450.                             + destFile.getAbsolutePath());
451.                 }
452.             } else {
453.                 // 不存在就创建一个新的空文件。
454.                 if (!destFile.createNewFile()) {
455.                     throw new IOException("Cannot write the destination file: "
456.                             + destFile.getAbsolutePath());
457.                 }
458.             }
459.         }
460.         BufferedOutputStream outputStream = null;
461.         ZipOutputStream zipOutputStream = null;
463.         FileOutputStream fout = new FileOutputStream(destFile);
464.         outputStream = new BufferedOutputStream(fout);
465.         zipOutputStream = new ZipOutputStream(outputStream, "gbk");
466.         zipOutputStream.setComment("通过java程序压缩的");
468.         try {
469.             zipDir(srcFile, zipOutputStream);// 压缩文件
470.             zipOutputStream.flush();
471.             zipOutputStream.finish();
472.         } finally {
473.             if (zipOutputStream != null) {
474.                 try {
475.                     zipOutputStream.close();
476.                 } catch (IOException ex) {
477.                     // just ignore
478.                 }
479.             }
480.             if (outputStream != null) {
481.                 try {
482.                     outputStream.close();
483.                 } catch (IOException ex) {
484.                     // just ignore
485.                 }
486.             }
487.             if (fout != null) {
488.                 try {
489.                     fout.close();
490.                 } catch (IOException ex) {
491.                     // just ignore
492.                 }
493.             }
494.         }
496.     }
498.     /**
499.      * 压缩文件夹
500.      * 
501.      * @param srcFile
502.      * @param zipOutputStream
503.      * @throws IOException
504.      */
505.     private void zipDir(File srcFile, ZipOutputStream zipOutputStream)
506.             throws IOException {
508.         if (srcFile.isFile()) {
509.             if (log.isDebugEnabled()) {
510.                 log.debug(srcFile.getAbsolutePath());
511.             }
512.             
513.             System.out.println("要压缩的文件"+srcFile.getAbsolutePath());
514.             FileInputStream fin = null;
515.             BufferedInputStream inputStream = null;
517.             byte[] block = new byte[1024];
518.             try {
519.                 fin = new FileInputStream(srcFile);
520.                 inputStream = new BufferedInputStream(fin);
522.                 ZipEntry zipEntry = new ZipEntry(srcFile.getAbsolutePath());// 获取文件的绝对路径
523.                 zipOutputStream.putNextEntry(zipEntry);
524.                 while (true) {
525.                     int readLength = inputStream.read(block);
526.                     if (readLength == -1)
527.                         break;// end of file
528.                     zipOutputStream.write(block, 0, readLength);
529.                 }
531.             } finally {
532.                 if (inputStream != null) {
533.                     try {
534.                         inputStream.close();
535.                     } catch (IOException ex) {
536.                         // just ignore
537.                     }
538.                 }
539.                 if (fin != null) {
540.                     try {
541.                         fin.close();
542.                     } catch (IOException ex) {
543.                         // just ignore
544.                     }
545.                 }
547.             }
548.         }
549.         if (srcFile.isDirectory()) { // 文件夹，进行递归
550.             File[] srcFiles = srcFile.listFiles();
551.             for (File temp : srcFiles) {
552.                 zipDir(temp, zipOutputStream);
553.             }
554.         }
556.     }
558.     /**
559.      * @param args
560.      * @throws IOException
561.      */
562.     public static void main(String[] args) throws IOException {
563. //      ZipUtil z = new ZipUtil();
564. //      // z.zipDir("d:/logs", "", true);
565. //      // System.out.println("压缩结束");
566. //      z.unzipDir("d:/logs.zip", true);
567. //      System.out.println("解压缩结束");
568.         
569.         String sysTemp = System.getProperty("java.io.tmpdir");//获取到系统临时目录
570.         //C:/DOCUME~1/WANGMI~1/LOCALS~1/Temp/
571.         sysTemp = sysTemp.replace("//", "/");
572.         ZipUtil z = new ZipUtil();
573.         z.zipFile("d:/logs/work.log",sysTemp,System.currentTimeMillis()+"", true);
574.         System.out.println("结束");
575.     }
576. }