Descompactação de um arquivo .gz

import java.util.*;
import java.util.zip.*;
import java.io.*;
import java.security.*;

class TesteGZIPInputStream {
    /** Cria um arquivo de teste. Para que o arquivo seja compressível, devemos gerar dados aleatórios, mas não tanto. 
        Uma forma de fazer isso é criar um array grande, cheio de zeros, e preencher aleatoriamente apenas 
        20% desse array com dados aleatórios. */
    public void criarArquivoTeste (File arq, int nBytes) throws IOException {
        byte[] bytes = new byte[nBytes]; // criando o array cheio de zeros
        Random r = new Random();
        for (int n = nBytes / 5; n >= 0; --n) {
            bytes[r.nextInt (nBytes)] = (byte) r.nextInt();
        }
        OutputStream os = new FileOutputStream (arq);
        os.write (bytes);
        os.close();
    }
    /** Comprime o arquivo */
    public void comprimir (File original, File comprimido) throws IOException {
        if (original.getAbsoluteFile().equals(comprimido.getAbsoluteFile())) {
            throw new IllegalArgumentException ("O arquivo de origem e o de destino não podem ser o mesmo");
        }
        InputStream is = new FileInputStream (original);
        GZIPOutputStream gzos = new GZIPOutputStream (new FileOutputStream (comprimido));
        byte[] buffer = new byte[16 * 1024];
        for (int nBytesLidos = is.read (buffer); nBytesLidos > 0; nBytesLidos = is.read(buffer)) {
            gzos.write (buffer, 0, nBytesLidos);
        }
        is.close();
        gzos.close();
    }
    /** Descomprime o arquivo */
    public void descomprimir (File comprimido, File descomprimido) throws IOException {
        if (comprimido.getAbsoluteFile().equals(descomprimido.getAbsoluteFile())) {
            throw new IllegalArgumentException ("O arquivo de origem e o de destino não podem ser o mesmo");
        }
        GZIPInputStream gzis = new GZIPInputStream (new BufferedInputStream (new FileInputStream (comprimido)));
        OutputStream os = new BufferedOutputStream (new FileOutputStream (descomprimido));
        byte[] buffer = new byte[16 * 1024];
        for (int nBytesLidos = gzis.read (buffer); nBytesLidos > 0; nBytesLidos = gzis.read(buffer)) {
            os.write (buffer, 0, nBytesLidos);
        }
        gzis.close();
        os.close();
    }
    
    /** 
     Retorna true se os arquivos forem iguais, e false em caso contrário. Na verdade
     iremos conferir apenas os digests de ambos os arquivos, porque isso costuma ser bem mais rápido
     que conferir byte por byte. 
     */
    public boolean conferirArquivo (File arq1, File arq2) throws Exception {
        byte[] digest1 = digestArquivo (arq1);
        byte[] digest2 = digestArquivo (arq2);
        return Arrays.equals (digest1, digest2);
    }
    
    public byte[] digestArquivo (File arq) throws Exception {
        MessageDigest sha512 = MessageDigest.getInstance ("SHA-512");
        DigestInputStream dis = new DigestInputStream (new BufferedInputStream (new FileInputStream (arq)), sha512);
        byte[] buffer = new byte[16 * 1024];
        for (int nBytesLidos = dis.read (buffer); nBytesLidos > 0; nBytesLidos = dis.read (buffer)) {
        }
        dis.close();
        return sha512.digest();
    }

    public static void main(String[] args) throws Exception {
        TesteGZIPInputStream t = new TesteGZIPInputStream();
        t.criarArquivoTeste (new File ("teste.txt"), 1024 * 1024 + 237);
        t.comprimir (new File ("teste.txt"), new File ("teste.txt.gz"));
        t.descomprimir (new File ("teste.txt.gz"), new File ("teste.txt.2"));
        System.out.println (t.conferirArquivo (new File ("teste.txt"), new File ("teste.txt.2")));
    }
}

try {
        // Open the compressed file
        String inFilename = "infile.gzip";
        GZIPInputStream in = new GZIPInputStream(new FileInputStream(inFilename));
    
        // Open the output file
        String outFilename = "outfile";
        OutputStream out = new FileOutputStream(outFilename);
    
        // Transfer bytes from the compressed file to the output file
        byte[] buf = new byte[1024];
        int len;
        while ((len = in.read(buf)) > 0) {
            out.write(buf, 0, len);
        }
    
        // Close the file and stream
        in.close();
        out.close();
    } catch (IOException e) {
    }