ZIP Data Compression with Java

Do you need the ability to add data compression to your enterprise application? Well, look no further because Java 1.1 provides a package for zip-compatible data compression. The new package, java.util.zip, allows software developers to read, create, modify and write PKZIP and GZIP compatible files.

By using the java.util.zip package, you will be able to incorporate sophisticated compression technology into your Java applications with minimal work. The package not only provides single file compression but you can also create multi-file archives. Since the ZIP files created by the package adhere to the ZIP standard, you will be able to use these files with the PKZIP utility.

Uncompressing a ZIP file is simply a matter of reading data from an input stream. In this example, we will write the code fragments to unzip the contents of a file secrets.zip. The five step process follows:

The java.util.zip package provides a class ZipInputStream for sequentially reading ZIP files. The constructor for this class accepts an InputStream object. As you can see, a ZipInputStream is created similar to other input streams.

Once the ZIP input stream is opened, then you can get each zip entry one at time. The getNextEntry() method returns a ZipEntry() object. If the end-of-file is reached then getNextEntry() will return null.

        while ( (theEntry = source.getNextEntry()) != null )
{
	// read the data
	//
	// more code to come
}

After the getNextEntry() method is called, then you can begin reading the data associated with this ZipEntry.

Now is a good time to setup the uncompressed output stream. This code is placed inside of the while-loop from step 2.

A file output stream is created using the entry’s name. The method Entry.getName() will return the name of the entry which is the file name of the compressed file.

        while ((byteCount = source.read(data, 0, DATA_BLOCK_SIZE)) != -1)
{
	targetStream.write(data, 0, byteCount);
}

The read() method retrieves data from the source zipped input stream. This method will return the number of bytes read in. If end-of-file is reached, then the read() method will return a -1. For each block of data that is read in, it is then written to the uncompressed target stream.

After processing the data for each entry (ie reading and writing), the target stream is flushed and closed.

Finally, after all entries are processed, the source input stream is also closed.

Listing 1 contains a complete code example. The file jkunzip.java incorporates the above steps and works as a command-line decompression utility. You can compile the program by typing:

To test the jkunzip utility, you can enter the command below. You must provide a zip file name.

In order to compress data to a ZIP file, you can use the ZipOutputStream class. This class provides the functionality of writing the data in a compressed format. There is only a small amount of work required by the developer to create a ZIP file. The simple six step process is outlined below.

The java.util.zip package provides the class ZipOutputStream for writing ZIP files. The constructor for this class accepts an OutputStream object. Basically, you can pass the output stream of the file you are writing to. Here is an example of creating a ZIP file titled "modules.zip":

fos = new FileOutputStream("modules.zip");
targetStream = new ZipOutputStream(fos);
targetStream.setMethod(ZipOutputStream.DEFLATED);

Notice the call to setMethod(). By passing the value of DEFLATED, the ZipOutputStream object will store the files in a compressed manner. By default, the compression method is set to ZipOutputStream.DEFLATED.

You also have the option of just storing the files in an uncompressed format. To accomplish this, you pass the value of ZipOutputStream.STORED to the setMethod() routine. However, when storing files in an uncompressed format, you must specify the CRC-32 checksum and the file size. Please reference the JDK 1.1 API for details on the CRC32 class.

You can also set the level of compression by calling the setLevel(int aLevel) method. The compression levels range from 1-9 with 1 being the weakest and 9 being the fastest level of compression.

Now that the target zip output stream is created, you can open the source data file. In this code example, the file "java_intro.ppt" is the source data file:

String dataFileName = "java_intro.ppt";
fis = new FileInputStream(dataFileName);
sourceStream = new BufferedInputStream(fis);

You will need to create a zip entry for each data file that is read. Recall from an earlier section that a zip entry contains file information such as the file name, original size, compressed size and additional details. Most of the zip entry information will be updated once the data is written to the zip output stream. Here is the code for creating a ZipEntry object:

Finally, the coast is clear for you to read the source file and write the data. Since you are writing to a zip output stream, the data will be written in a compressed format without any additional work by you.

You can close the zip entry when you are finished writing the data. By closing the zip entry, the ZipEntry object is updated with the compressed file size, uncompressed file size and other file related information. It is also a good idea to close any open streams.

Listing 2 contains a complete code example. The file jkzip.java incorporates the above steps and works as a command-line compression utility. You can compile the program by typing:

To test the jkzip utility, you can enter the command below. You must provide a zip file name and an optional list of files to compress.

At any time, you can find out the properties of a given ZIP file. Recall that the ZIP file is composed of zip entries for each compressed file. The ZipEntry class has a number of useful methods for accessing compressed file details (see figure 2).

Here is a description of the popular methods available in the ZipEntry class:

Here is a code sample that uses some of the above methods to display information for a given ZipEntry

In the jkunzip program, functionality was added to display the contents of a given zip file. Refer to Listing 1 and view the listContents() method. You can use the "-v" option on the jkunzip program to list the zip file contents.

Chád (shod) Darby is a Java consultant for J9 Consulting, www.j-nine.com. He specializes in developing server-side Java applications and database applications. Chád received a B.S. in Computer Science from Carnegie Mellon University. You can reach him at darby@j-nine.com..