Elegant Engineering

Data Compression Using Java - Part 2

2008-12-11T10:51:00.001-08:00

In Part 1 of this series I detailed the types of compression, their formats, and when you might want to use each one. This portion of the discussion will begin detailing how to use the Java compression implementations contained within the java.util.zip package.

Methods of Compression

If you read the JavaDocs for the java.util.zip package you will quickly notice that there are many more classes than the ones I will be discussing. Some of the java.util.zip classes perform compression, some wrap their functionality with InputStream and OutputStream, and others support checksum functionality. The compression classes I demonstrate in this posting should address the majority of your needs so don’t feel overwhelmed by the choices available.

The three Java compression methods that I will be discussing are:

Zip Compression (using ZipOutputStream and ZipInputStream)
GZip Compression (using GZipOutputStream and GZipInputStream)
DEFLATE Compression (using DeflaterOutputStream and InflaterInputStream)

The first question we need to address is when to use each of thee compression types. All three compression types (zip, gzip, and deflate) use the exact same DEFLATE algorithm internally to compress data. The only reason there are multiple formats to choose from is because each format has unique features that make it desirable under certain circumstances.

We will be discussing the compression types in order of most overhead to least overhead. The examples provided will demonstrate compressing a single file so similarities and differences between the compression methods can be better illustrated.

Amazon.com Widgets

Zip

The zip compression format is desirable for compressing multiple directories and files. In Part 1 of this series I explained that zip is an archiver and compressor, which allows it to store and compress multiple directories and files.

Zip compression is easily implemented by using the ZipOutputStream and ZipInputStream classes. The following example will only zip a single file to better illustrate code similarities between zip, gzip, and DEFLATE.

Compressing and uncompressing an individual file using zip:

package compression;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.CRC32;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class ZipCompression {

    private final static String FILE_NAME = "data";

    public static void main(String[] args) throws IOException {
        File dataFile = new File(FILE_NAME);

        // read and compress file data in memory using zip format
        byte[] zippedData = zipData(dataFile);

        // persist zipped data to disk
        File zippedFile = new File(FILE_NAME + ".zip");
        writeData(zippedData, zippedFile);

        // read and uncompress zipped file data in memory
        byte[] unzippedData = unzipData(zippedFile);

        // persist unzipped data to disk
        File unzippedFile = new File(FILE_NAME + "-unzipped");
        writeData(unzippedData, unzippedFile);

        // verify our methods are not corrupting data (for debug only)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        readData(dataFile, baos);
        byte[] originalFileData = baos.toByteArray();

        baos.reset();

        readData(unzippedFile, baos);
        byte[] unzippedFileData = baos.toByteArray();

        boolean match = checksumsMatch(originalFileData, unzippedFileData);
        System.out.println("Checksums match: " + match);
    }

    private static byte[] zipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ZipOutputStream zipos = new ZipOutputStream(baos);
        ZipEntry entry = new ZipEntry(f.getName());
        zipos.putNextEntry(entry);
        readData(f, zipos);
        return baos.toByteArray();
    }

    private static byte[] unzipData(File f) throws IOException {
        InputStream is = new BufferedInputStream(new FileInputStream(f));
        ZipInputStream zipis = new ZipInputStream(is);
        zipis.getNextEntry();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = zipis.read(buf)) > 0) {
            baos.write(buf, 0, len);
        }
        return baos.toByteArray();
    }

    private static void readData(File f, OutputStream os) throws IOException {
        byte[] buf = new byte[1024];
        int len = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(f));
            while ((len = is.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            if (os instanceof DeflaterOutputStream) {
                ((DeflaterOutputStream) os).finish();
            }
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    private static void writeData(byte[] data, File f) throws IOException {
        OutputStream os = null;
        try {
            os = new BufferedOutputStream(new FileOutputStream(f));
            os.write(data);
        } finally {
            if (os != null) {
                os.close();
            }
        }
    }

    private static boolean checksumsMatch(byte[] d1, byte[] d2) {
        CRC32 crc = new CRC32();
        crc.update(d1);
        long checksum1 = crc.getValue();
        crc.reset();
        crc.update(d2);
        long checksum2 = crc.getValue();
        return (checksum1 == checksum2);
    }
}

The program does the following:

Reads a single data file
Compresses the file using zip
Writes the zipped file to the hard disk
Reads the zipped file from hard disk
Unzips the file data
Writes the unzipped file to the hard disk

At the end of this program you will have three files. The “data” (original) file, the “data.zip” (compressed) file, and the “data-unzipped” (uncompressed) file. The original “data” file and uncompressed “data-unzipped” file should be identical.

You will notice in the code above that I have included additional functionality to determine the CRC32 checksum for the input “data” file and uncompressed “data-unzipped” file. These checks are there to verify that corruption did not occur at any point during compression, decompression, file input/output. When using zip and gzip you should not need these manual checksum tests as both zip and gzip implement a form of checksum. I included the checksum code for illustration purposes only.

GZip

The gzip compression format is desirable for compressing individual files or data streams. The gzip format has the ability to compress a single file or single data stream without incurring the overhead that zip incurs due to directory and file metadata storage.

Compressing and uncompressing an individual file using gzip:

package compression;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.zip.CRC32;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GzipCompression {

    private final static String FILE_NAME = "data";

    public static void main(String[] args) throws IOException {
        File dataFile = new File(FILE_NAME);

        // read and compress file data in memory using gzip format
        byte[] gzippedData = gzipData(dataFile);

        // persist gzipped data to disk
        File gzippedFile = new File(FILE_NAME + ".gzip");
        writeData(gzippedData, gzippedFile);

        // read and uncompress gzipped file data in memory
        byte[] ungzippedData = ungzipData(gzippedFile);

        // persist ungzipped data to disk
        File ungzippedFile = new File(FILE_NAME + "-ungzipped");
        writeData(ungzippedData, ungzippedFile);

        // verify our methods are not corrupting data (for debug only)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        readData(dataFile, baos);
        byte[] originalFileData = baos.toByteArray();

        baos.reset();

        readData(ungzippedFile, baos);
        byte[] ungzippedFileData = baos.toByteArray();

        boolean match = checksumsMatch(originalFileData, ungzippedFileData);
        System.out.println("Checksums match: " + match);
    }

    private static byte[] gzipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gzipos = new GZIPOutputStream(baos);
        readData(f, gzipos);
        return baos.toByteArray();
    }

    private static byte[] ungzipData(File f) throws IOException {
        InputStream is = new BufferedInputStream(new FileInputStream(f));
        GZIPInputStream gzipis = new GZIPInputStream(is);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = gzipis.read(buf)) > 0) {
            baos.write(buf, 0, len);
        }
        return baos.toByteArray();
    }

    private static void readData(File f, OutputStream os) throws IOException {
        byte[] buf = new byte[1024];
        int len = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(f));
            while ((len = is.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            if (os instanceof DeflaterOutputStream) {
                ((DeflaterOutputStream) os).finish();
            }
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    private static void writeData(byte[] data, File f) throws IOException {
        OutputStream os = null;
        try {
            os = new BufferedOutputStream(new FileOutputStream(f));
            os.write(data);
        } finally {
            if (os != null) {
                os.close();
            }
        }
    }

    private static boolean checksumsMatch(byte[] d1, byte[] d2) {
        CRC32 crc = new CRC32();
        crc.update(d1);
        long checksum1 = crc.getValue();
        crc.reset();
        crc.update(d2);
        long checksum2 = crc.getValue();
        return (checksum1 == checksum2);
    }
}

The program does the following:

Reads a single data file
Compresses the file using gzip
Writes the gzipped file to the hard disk
Reads the gzipped file from hard disk
Ungzips the file data
Writes the ungzipped file to the hard disk

The CRC checksum is only included in this example for illustration purposes only.

DEFLATE

The DEFLATE compression format is lightweight and desirable for individual files or data streams that do not require error checking. DEFLATE is used by zip and gzip to compress data; however both zip and gzip add additional overhead such as CRC checksums. Directory metadata is additionally added to the zip format.

When using DEFLATE directly you can control the compression strategy and level. A compression level of 0-9 may be used to control how DEFLATE compresses data.

Compressing and decompressing an individual file using DEFLATE:

package compression;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.CRC32;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

public class DeflateCompression {

    private final static String FILE_NAME = "data";

    public static void main(String[] args) throws IOException {
        File dataFile = new File(FILE_NAME);

        // read and compress file data in memory using deflate format
        byte[] deflatedData = deflateData(dataFile);

        // persist deflated data to disk
        File deflatedFile = new File(FILE_NAME + ".def");
        writeData(deflatedData, deflatedFile);

        // read and uncompress deflated file data in memory
        byte[] inflatedData = inflateData(deflatedFile);

        // persist deflated data to disk
        File inflatedFile = new File(FILE_NAME + "-inflated");
        writeData(inflatedData, inflatedFile);

        // verify our methods are not corrupting data (for debug only)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        readData(dataFile, baos);
        byte[] originalFileData = baos.toByteArray();

        baos.reset();

        readData(inflatedFile, baos);
        byte[] inflatedFileData = baos.toByteArray();

        boolean match = checksumsMatch(originalFileData, inflatedFileData);
        System.out.println("Checksums match: " + match);
    }

    private static byte[] deflateData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Deflater def = new Deflater(Deflater.BEST_COMPRESSION);
        DeflaterOutputStream deflaterOS = new DeflaterOutputStream(baos, def);
        readData(f, deflaterOS);
        return baos.toByteArray();
    }

    private static byte[] inflateData(File f) throws IOException {
        InputStream is = new BufferedInputStream(new FileInputStream(f));
        InflaterInputStream inflateris = new InflaterInputStream(is);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = inflateris.read(buf)) > 0) {
            baos.write(buf, 0, len);
        }
        return baos.toByteArray();
    }

    private static void readData(File f, OutputStream os) throws IOException {
        byte[] buf = new byte[1024];
        int len = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(f));
            while ((len = is.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            if (os instanceof DeflaterOutputStream) {
                ((DeflaterOutputStream) os).finish();
            }
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    private static void writeData(byte[] data, File f) throws IOException {
        OutputStream os = null;
        try {
            os = new BufferedOutputStream(new FileOutputStream(f));
            os.write(data);
        } finally {
            if (os != null) {
                os.close();
            }
        }
    }

    private static boolean checksumsMatch(byte[] d1, byte[] d2) {
        CRC32 crc = new CRC32();
        crc.update(d1);
        long checksum1 = crc.getValue();
        crc.reset();
        crc.update(d2);
        long checksum2 = crc.getValue();
        return (checksum1 == checksum2);
    }
}

The program does the following:

Reads a single data file
Compresses the file using DEFLATE
Writes the deflated file to the hard disk
Reads the deflated file from hard disk
Inflates the file data
Writes the inflated file to the hard disk

The CRC checksum is only included in this example for illustration purposes only.

Compressing Objects

What if you need to compress objects instead of files? The main difference is that the ObjectOutputStream and ObjectInputStreams classes must wrap the DeflaterOutputStream and InflaterInputStream classes to deflate a serialized object. The Decorator Pattern is used by the JDK to achieve this ability of wrapping InputStreams and OutputStreams to gain functionality.

Compressing and decompressing serialized objects using DEFLATE:

package compression;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

public class ObjectCompression {

    public static class Person implements Serializable {

        private String firstName;
        private String lastName;
        private String address;

        public Person(String fn, String ln, String addr) {
            firstName = fn;
            lastName = ln;
            address = addr;
        }

        @Override
        public String toString() {
            String data = String.format("data={%s,%s,%s}", firstName, lastName,
                    address);
            return data;
        }
    }

    public static void main(String[] args) throws Exception {
        Person person = new Person("John", "Smith", "100 Memory Lane");

        // serialize Person object without compression (determine raw size)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(person);
        oos.flush();
        oos.close();
        byte[] serializedPerson = baos.toByteArray();

        // serialized and compress Person object
        byte[] deflatedPerson = deflateObject(person);

        // decompress deserialize Person object
        Person inflatedPerson = (Person) inflateObject(deflatedPerson);

        // print results
        int uncompressedSize = serializedPerson.length;
        System.out.print("Before Compression: (" + uncompressedSize
                 + " bytes) ");
        System.out.println(person);

        int compressedSize = deflatedPerson.length;
        System.out.print("After Compression: (" + compressedSize + " bytes) ");
        System.out.println(inflatedPerson);
    }

    private static byte[] deflateObject(Object o) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Deflater def = new Deflater(Deflater.BEST_COMPRESSION);
        DeflaterOutputStream deflaterOS = new DeflaterOutputStream(baos, def);
        ObjectOutputStream oos = new ObjectOutputStream(deflaterOS);
        oos.writeObject(o);
        oos.flush();
        oos.close();
        return baos.toByteArray();
    }

    private static Object inflateObject(byte[] d) throws Exception {
        ByteArrayInputStream data = new ByteArrayInputStream(d);
        InflaterInputStream inflaterIS = new InflaterInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(inflaterIS);
        Object obj = ois.readObject();
        ois.close();
        return obj;
    }
}

The following output was generated by running this code:

Before Compression: (154 bytes) data={John,Smith,100 Memory Lane}
After Compression: (143 bytes) data={John,Smith,100 Memory Lane}

A savings of 11 bytes was achieved by using compression on this single Person object. The savings may not seem impressive by itself, but compressing a List object containing 1000 Person objects may yield substantial savings.

Summary

The compression capabilities of the JDK are very robust and should be sufficient for most situations. Three compression types exist in the java.util.zip package zip , gzip, and DEFLATE. Each of the compression types offers unique capabilities.

Generally zip is used for compressing multiple directories and files. Gzip is suited for compressing single files or streams of data. The DEFLATE compression type is lightweight and is a great choice for compressing streams of data that do not require error checking.

References

http://en.wikipedia.org/wiki/ZIP_(file_format)#The_format_in_detail
http://en.wikipedia.org/wiki/Gzip#File_format
http://java.sun.com/developer/technicalArticles/Programming/compression/
http://tools.ietf.org/html/rfc1951
http://en.wikipedia.org/wiki/DEFLATE

Data Compression Using Java - Part 1

2008-12-03T13:34:00.001-08:00

Understanding compression is beneficial whether you are building a file archiving utility or simply trying to get better throughput with your web services. The JDK offers robust compression formats such as zip and gzip to handle most situations you are likely to encounter. A basic understanding of compression is required before diving into Java-specific implementations and their usages.

DEFLATE

At their core both zip and gzip use the DEFLATE algorithm. DEFLATE is a lossless data compression algorithm that uses a combination of the LZ77 algorithm and Huffman coding. Keep in mind that DEFLATE is only the means by which zip and gzip compress data and their individual features and formats are quite different.

It is possible to use DEFLATE directly without incurring the additional overhead that zip and gzip incur. You lose some features such as Cyclic Redeundancy Checking (CRC) checksumming to detect data corruption, however the overhead reduction can be substantial in some cases. This approach may be appealing when compressing streams of data that are not persisted to hard disk.

Zip

The zip archive format consists of individual file entries and a central directory located at the end of the zip file that contains the offsets for the individual file entries. Compression is applied to the individual file entries within the zip archive, not the archive file as a whole. This method of compression is not without its drawbacks.

The ZIP format can hold collections of files without an external archiver, but is less compact than compressed tarballs holding the same data, because it compresses files individually and cannot take advantage of redundancy between files (Wikipedia)

The alternative to using zip is to use tar and gzip to archive and compress directories in a two step process. First, the tar algorithm creates an archive similar to a zip archive, except that the tar archive is not compressed. Next, gzip compression can be applied to the tar to create a .tar.gz or .tgz sometimes referred to as a tarball.

One benefit of using tar and gzip over zip is that tarring and gzipping can take advantage of solid compression. Solid compression concatenates the data of all files contained within the archive and then treats that data as a single block, which allows the compression algorithm to better compress the redundant file data.

Amazon.com Widgets

GZip

The gzip algorithm is designed to compress individual files or streams of data. Gzip does not handle compressing multiple files or directories the way zip can. If you want to gzip a directory, you must first tar it, then gzip it.

File Compression Overhead

Each type of compression incurs overhead. The overhead generated by zip is greater than that of gzip due to zip storing directory metadata for the archive. Remember, gzip is a compressor only, not an archiver and compressor.

To illustrate this concept of compression overhead I compressed a single 4608 byte binary file using both zip and gzip. Your mileage may vary.

Compression Results:

raw    4608
zip    1903
gzip   1799

The code I used to test compression overhead:

package compression;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class FileCompressionOverhead {

    private final static String FILE_NAME = "data";

    public static void main(String[] args) throws IOException {
        File binFile = new File(FILE_NAME);
        long rawSize = binFile.length();

        byte[] zip = zipData(binFile);
        int zipSize = zip.length;

        byte[] gzip = gzipData(binFile);
        int gzipSize = gzip.length;

        String output = String.format("raw\t%d\nzip\t%d\ngzip\t%d", rawSize,
                zipSize, gzipSize);
        System.out.println(output);
    }

    private static byte[] zipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ZipOutputStream zipos = new ZipOutputStream(baos);
        ZipEntry entry = new ZipEntry(f.getName());
        zipos.putNextEntry(entry);
        readData(f, zipos);
        return baos.toByteArray();
    }

    private static byte[] gzipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gzipos = new GZIPOutputStream(baos);
        readData(f, gzipos);
        return baos.toByteArray();
    }

    private static void readData(File f, OutputStream os) throws IOException {
        byte[] buf = new byte[1024];
        int len = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(f));
            while ((len = is.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            ((DeflaterOutputStream) os).finish();
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }
}

Compressible Data

Not all data compresses the same way. The compression ratio is directly related to the randomness of the data. We can generate a pseudo-random binary file and attempt to compress it with both zip and gzip.

The data will not compress well due to the distribution of data, in fact this example will actually cause the compressed files to be larger than the original uncompressed version. The reason this happens is because generating a dictionary and eliminating duplication is difficult when the data is random.

Compression Results:

raw    2048
zip    2187
gzip   2071

The code I used to test compressible data:

package compression;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Random;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class CompressableData {

    private final static String FILE_NAME = "randomdata";

    private final static int FILE_SIZE = 2048;

    public static void main(String[] args) throws IOException {
        createRandomByteFile(FILE_SIZE);

        File binFile = new File(FILE_NAME);
        long rawSize = binFile.length();

        byte[] zip = zipData(binFile);
        int zipSize = zip.length;

        byte[] gzip = gzipData(binFile);
        int gzipSize = gzip.length;

        String output = String.format("raw\t%d\nzip\t%d\ngzip\t%d", rawSize,
                zipSize, gzipSize);
        System.out.println(output);
    }

    private static void createRandomByteFile(int size) throws IOException {
        byte[] data = new byte[size];
        new Random().nextBytes(data);
        File f = new File(FILE_NAME);
        OutputStream os = null;
        try {
            os = new BufferedOutputStream(new FileOutputStream(f));
            os.write(data);
        } finally {
            if (os != null) {
                os.close();
            }
        }
    }

    private static byte[] zipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ZipOutputStream zipos = new ZipOutputStream(baos);
        ZipEntry entry = new ZipEntry(f.getName());
        zipos.putNextEntry(entry);
        readData(f, zipos);
        return baos.toByteArray();
    }

    private static byte[] gzipData(File f) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gzipos = new GZIPOutputStream(baos);
        readData(f, gzipos);
        return baos.toByteArray();
    }

    private static void readData(File f, OutputStream os) throws IOException {
        byte[] buf = new byte[1024];
        int len = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(f));
            while ((len = is.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            ((DeflaterOutputStream) os).finish();
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }
}

Summary

From a programming perspective you will typically use zip for compressing directories/files and gzip for compressing streams of data. Also remember that you can never be absolutely sure what compression ratio you will get among varying file types. In Part 2 of this series I will discuss how to utilize the Java implementation of the compression technologies mentioned in this post.

References

http://en.wikipedia.org/wiki/ZIP_(file_format)#The_format_in_detail
http://en.wikipedia.org/wiki/Gzip#File_format
http://java.sun.com/developer/technicalArticles/Programming/compression/
http://tools.ietf.org/html/rfc1951
http://en.wikipedia.org/wiki/DEFLATE