Sample Java unzip file

If using Java's built-in compression kit to realize the function of unzip the file to the specified folder, because the JDK provides the zip can only be handled as utf-8, and in the Windows system file name is a way of GBK code, so if it is unzip a zip package contains the file name in Chinese, the illegal abnormal parameters, so in order to realize the decompression, Have to DeflaterOutputStream. Java, InflaterInputStream. Java, ZipConstants. Java, ZipEntry. Java, ZipInputStream. Java and ZipOutputStream. Java these related classes, modified process is as follows:
Since J2SE 1.4, the Java compiler no longer supports the import of classes and interfaces with unnamed package names, so in the Java project created, we must create a new package of our own definition, the package name format is generally the reverse of the school domain name + their own network name, such as cn.edu.xidian.crytoll.
Create a new DeflaterOutputStream class in the package. The code is as follows:

DeflaterOutputStream. Java:

package cn.edu.xdian.crytoll;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.zip.Deflater;

/**
 * This class implements an output stream filter for compressing data in
 * the "deflate" compression format. It is also used as the basis for other
 * types of compression filters, such as GZIPOutputStream.
 *
 * @see     Deflater
 * @version     1.36, 03/13/06
 * @author  David Connelly
 */
public
class DeflaterOutputStream extends FilterOutputStream {
    
    protected Deflater def;

    
    protected byte[] buf;

    

    private boolean closed = false;

    
    public DeflaterOutputStream(OutputStream out, Deflater def, int size) {
        super(out);
        if (out == null || def == null) {
            throw new NullPointerException();
        } else if (size <= 0) {
            throw new IllegalArgumentException("buffer size <= 0");
        }
        this.def = def;
        buf = new byte[size];
    }

    
    public DeflaterOutputStream(OutputStream out, Deflater def) {
    this(out, def, 512);
    }

    boolean usesDefaultDeflater = false;

    
    public DeflaterOutputStream(OutputStream out) {
    this(out, new Deflater());
        usesDefaultDeflater = true;
    }

    /**
     * Writes a byte to the compressed output stream. This method will
     * block until the byte can be written.
     * @param b the byte to be written
     * @exception IOException if an I/O error has occurred
     */
    public void write(int b) throws IOException {
        byte[] buf = new byte[1];
    buf[0] = (byte)(b & 0xff);
    write(buf, 0, 1);
    }

    /**
     * Writes an array of bytes to the compressed output stream. This
     * method will block until all the bytes are written.
     * @param b the data to be written
     * @param off the start offset of the data
     * @param len the length of the data
     * @exception IOException if an I/O error has occurred
     */
    public void write(byte[] b, int off, int len) throws IOException {
    if (def.finished()) {
        throw new IOException("write beyond end of stream");
    }
        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
        throw new IndexOutOfBoundsException();
    } else if (len == 0) {
        return;
    }
    if (!def.finished()) {
            // Deflate no more than stride bytes at a time.  This avoids
            // excess copying in deflateBytes (see Deflater.c)
            int stride = buf.length;
            for (int i = 0; i < len; i+= stride) {
                def.setInput(b, off + i, Math.min(stride, len - i));
                while (!def.needsInput()) {
                    deflate();
                }
            }
    }
    }

    /**
     * Finishes writing compressed data to the output stream without closing
     * the underlying stream. Use this method when applying multiple filters
     * in succession to the same output stream.
     * @exception IOException if an I/O error has occurred
     */
    public void finish() throws IOException {
    if (!def.finished()) {
        def.finish();
        while (!def.finished()) {
        deflate();
        }
    }
    }

    /**
     * Writes remaining compressed data to the output stream and closes the
     * underlying stream.
     * @exception IOException if an I/O error has occurred
     */
    public void close() throws IOException {
        if (!closed) {
            finish();
            if (usesDefaultDeflater)
                def.end();
            out.close();
            closed = true;
        }
    }

    /**
     * Writes next block of compressed data to the output stream.
     * @throws IOException if an I/O error has occurred
     */
    protected void deflate() throws IOException {
    int len = def.deflate(buf, 0, buf.length);
    if (len > 0) {
        out.write(buf, 0, len);
    }
    }
}