Java IO.pdf - Nguyen Dang Binh

Java I/O
if it doesn't, it will compress within a few percent of the optimal strategy, so it's rarely worth
agonizing over which is the best solution.
9.1.1.3 Set the compression level
The deflater compresses by trying to match the data it's looking at now to data it's already
seen earlier in the stream. The compression level determines how far back in the stream the
deflater looks for a match. The farther back it looks, the more likely it is to find a match and
the larger the run of bytes it can replace with a simple pointer. However, the farther back it
looks, the longer it takes as well. Thus, compression level is a trade-off between speed and
file size. The tighter you compress, the more time it takes. Generally, the compression level is
set in the constructor, but you can change it after the deflater is constructed by using the
setLevel() method:
public synchronized void setLevel(int Level)
As with the Deflater() constructors, the compression level should be an int between and 9
(no compression to maximum compression) or perhaps -1, signifying the default compression
level. Any other value will cause an IllegalArgumentException. It's good coding style to
use one of the mnemonic constants Deflater.NO_COMPRESSION (0), Deflater.BEST_SPEED
(1), Deflater.BEST_COMPRESSION (9), or Deflater.DEFAULT_COMPRESSION (-1) instead of
an explicit value.
In limited testing with small files, I haven't found the difference between best speed and best
compression to be noticeable, either in file size or the time it takes to compress or
decompress. You may occasionally want to set the level to no compression (0) if you're
deflating already compressed files like GIF, JPEG, or PNG images before storing them in an
archive. These file formats have built-in compression algorithms specifically designed for the
type of data they contain, and the general-purpose deflation algorithm provided here is
unlikely to compress them further. [2] It may even increase their size.
9.1.1.4 Set the dictionary
You can think of the deflater as building a dictionary of phrases as it reads the text. The first
time it sees a phrase, it puts the phrase in the dictionary. The second time it sees the phrase, it
replaces the phrase with its position in the dictionary. However, it can't do this until it's seen
the phrase at least once, so data early in the stream isn't compressed very well compared to
data that occurs later in the stream. On rare occasion, when you have a good idea that certain
byte sequences appear in the data very frequently, you can preset the dictionary used for
compression. You would fill the dictionary with the frequently repeated data in the text. For
instance, if your text is composed completely of ASCII digits and assorted whitespace (tabs,
carriage returns, and so forth) you could put those characters in your dictionary. This allows
the early part of the stream to compress as well as later parts.
There are two setDictionary() methods. The first uses the entire byte array passed as an
argument as the dictionary. The second uses the subarray of data starting at offset and
continuing for length bytes.
public void setDictionary(byte[] data)
2 In fact, the deflation algorithm described here is the exact algorithm used by PNG images; it was first invented specifically for the PNG file format.
143