|
SCOUG OS/2 For You - June 1999Cup of JavaZipping Alongby Terry WarrenIf you have ever tried to write code to deal with compressed data, such as that found in zipped files, then you will probably appreciate how easy it is to do this type of processing in Java. The JDK 1.1 includes a package, java.util.zip, which contains a set of classes designed specifically to facilitate reading and writing ZIPfiles. These classes can deal both with the lz compressed data (used by the various pkware zip/unzip programs) as well as the standard Unix variant (gzip). In addition, there are classes which provide iostreaming capabilities for compressing data "on the fly" and passing it in an extended io pipe. Zip BasicsThe basis for handling compressed data in Java is the concept of deflators and inflators - which are represented in the package by their corresponding classes: Deflator and Inflator. These classes encap-sulate objects that are capable of deflating (or inflating) a data into (or from) a data source. The Deflator class is designed to provide compression of data using a variety of parameters which define the type and extent of the compres-sion. The Inflator class handles data compressed via a Deflator object to un-compress it. These classes perform their functions via a buffer but are also extensible to support streamed data. The streamed data classes (DeflatorOutputStream and InflatorInputStream) work with Deflator or Inflator to handle data that is streamed to or from any iostream. In general, a program will deal with data at this level rather than directly at the Deflator/Inflator level. The package also provides several classes for dealing with specific types of compressed data:
Accessing a Zipped FileThe two main classes for accesing ZIPfile data are ZipFile and ZipEntry. You can attach a zipped file to a ZipFile object (via its constructor) and then access the various content files of the zipped file using ZipEntry objects. There are methods for obtaining information about the zipped file contents as well as processing the data in those contents.
For example, the following code fragment lists the contents of a ZIPfile for the filename passed in the method invocation: This method will list the names of all of the files in the zipfile along with their compressed file size and their uncompressed file size. There are also other attributes that can be listed such as the CRC value and timestamp. Extracting Files from a ZipThe next example shows how to extract a specified file (given by the second parameter) from within a zipped file (given by the first parameter) and write it to a normal file of the same name. The basic logic is to first get the appropriate entry within the ZIPfile and then open an input stream for this entry. An output stream is created and the data is transferred from the (compressed) input stream to the output file: If you want to process the entire zipfile, you can use the ZipInputStream against an inputstream from the file. Then use the getNextEntry() in a loop to automatically process the entries within the zipfile sequentially. In this case, the processing for each entry should test to see if the entry is a directory or a file: Creating a ZipYou can also write to zipfiles and/or create them, using primarily the ZipOutputStream class. This is more complex than reading since you must specify how to put the data into the file (STORED or DEFLATED) and, if DEFLATED, the level of compression. The following example shows how to write deflated files into a ZIPfile. The first parameter gives the name of the zipfile to create and the second parameter is a string array indicating the files to zip. Compressing Data StreamsWhile the zipped file handling capabilities described above are useful, the general concept of deflated and inflated iostreams (discussed briefly at the beginning of this article) is very powerful especially in client/server applications that need to pass significant volumes of data per transaction. Normally these applications would use TCP/IP sockets to communicate and would then open an iostream between the sockets to transfer data (the sending object would create an output stream and the receiving object an input stream). By simply wrapping the sending output stream with a DeflatorOuputStream the transmitting socket is now automatically compressing its data as it is being sent. The receiving socket can wrap its input stream with the InflatorInputStream if it wishes to decompress the data (or it can store the compressed data in a file or other object for later decompression). One drawback to this approach is that it works only if the server is always accessed by clients that are using the compression technique; if some clients are not then additional coding is needed to determine which type of stream is being received and handle both cases. A complete example of this type of coding is available through the SCOUG programming SIG webpage. LimitationsThere are some limitations on the use of these classes with existing zipped files. The ones I have encountered are:
SummaryJava JDK 1.1 provides a useful set of classes for dealing with compressed data, both in external file formats (pkzip and gzip) as well as at the iostream level for interprocess communication. Next time we will look at Java's exception handling model. Cup of Java by Terry Warren is a series that started in April 1999. Prior articles are:
P.O. Box 26904 Santa Ana, CA 92799-6904, USA Copyright 1999 the Southern California OS/2 User Group. ALL RIGHTS RESERVED. SCOUG, Warp Expo West, and Warpfest are trademarks of the Southern California OS/2 User Group.
|