public class Deflater extends Object
This class deflates sequences of bytes into ZLIB compressed data format. The input byte sequence is provided in either byte array or byte buffer, via one of the setInput()
methods. The output byte sequence is written to the output byte array or byte buffer passed to the deflate()
methods.
The following code fragment demonstrates a trivial compression and decompression of a string using Deflater
and Inflater
.
try { // Encode a String into bytes String inputString = "blahblahblah"; byte[] input = inputString.getBytes("UTF-8"); // Compress the bytes byte[] output = new byte[100]; Deflater compresser = new Deflater(); compresser.setInput(input); compresser.finish(); int compressedDataLength = compresser.deflate(output); compresser.end(); // Decompress the bytes Inflater decompresser = new Inflater(); decompresser.setInput(output, 0, compressedDataLength); byte[] result = new byte[100]; int resultLength = decompresser.inflate(result); decompresser.end(); // Decode the bytes into a String String outputString = new String(result, 0, resultLength, "UTF-8"); } catch (java.io.UnsupportedEncodingException ex) { // handle } catch (java.util.zip.DataFormatException ex) { // handle }
Deflater
, the end()
method should be called explicitly. Subclasses are responsible for the cleanup of resources acquired by the subclass. Subclasses that override Object.finalize()
in order to perform cleanup should be modified to use alternative cleanup mechanisms such as Cleaner
and remove the overriding finalize
method.Modifier and Type | Field | Description |
---|---|---|
static final int |
BEST_COMPRESSION |
Compression level for best compression. |
static final int |
BEST_SPEED |
Compression level for fastest compression. |
static final int |
DEFAULT_COMPRESSION |
Default compression level. |
static final int |
DEFAULT_STRATEGY |
Default compression strategy. |
static final int |
DEFLATED |
Compression method for the deflate algorithm (the only one currently supported). |
static final int |
FILTERED |
Compression strategy best used for data consisting mostly of small values with a somewhat random distribution. |
static final int |
FULL_FLUSH |
Compression flush mode used to flush out all pending output and reset the deflater. |
static final int |
HUFFMAN_ONLY |
Compression strategy for Huffman coding only. |
static final int |
NO_COMPRESSION |
Compression level for no compression. |
static final int |
NO_FLUSH |
Compression flush mode used to achieve best compression result. |
static final int |
SYNC_FLUSH |
Compression flush mode used to flush out all pending output; may degrade compression for some compression algorithms. |
Constructor | Description |
---|---|
Deflater() |
Creates a new compressor with the default compression level. |
Deflater |
Creates a new compressor using the specified compression level. |
Deflater |
Creates a new compressor using the specified compression level. |
Modifier and Type | Method | Description |
---|---|---|
int |
deflate |
Compresses the input data and fills specified buffer with compressed data. |
int |
deflate |
Compresses the input data and fills specified buffer with compressed data. |
int |
deflate |
Compresses the input data and fills the specified buffer with compressed data. |
int |
deflate |
Compresses the input data and fills specified buffer with compressed data. |
int |
deflate |
Compresses the input data and fills the specified buffer with compressed data. |
void |
end() |
Closes the compressor and discards any unprocessed input. |
void |
finish() |
When called, indicates that compression should end with the current contents of the input buffer. |
boolean |
finished() |
Returns true if the end of the compressed data output stream has been reached. |
int |
getAdler() |
Returns the ADLER-32 value of the uncompressed data. |
long |
getBytesRead() |
Returns the total number of uncompressed bytes input so far. |
long |
getBytesWritten() |
Returns the total number of compressed bytes output so far. |
int |
getTotalIn() |
Returns the total number of uncompressed bytes input so far. |
int |
getTotalOut() |
Returns the total number of compressed bytes output so far. |
boolean |
needsInput() |
Returns true if no data remains in the input buffer. |
void |
reset() |
Resets deflater so that a new set of input data can be processed. |
void |
setDictionary |
Sets preset dictionary for compression. |
void |
setDictionary |
Sets preset dictionary for compression. |
void |
setDictionary |
Sets preset dictionary for compression. |
void |
setInput |
Sets input data for compression. |
void |
setInput |
Sets input data for compression. |
void |
setInput |
Sets input data for compression. |
void |
setLevel |
Sets the compression level to the specified value. |
void |
setStrategy |
Sets the compression strategy to the specified value. |
public static final int DEFLATED
public static final int NO_COMPRESSION
public static final int BEST_SPEED
public static final int BEST_COMPRESSION
public static final int DEFAULT_COMPRESSION
public static final int FILTERED
public static final int HUFFMAN_ONLY
public static final int DEFAULT_STRATEGY
public static final int NO_FLUSH
public static final int SYNC_FLUSH
public static final int FULL_FLUSH
public Deflater(int level, boolean nowrap)
level
- the compression level (0-9)nowrap
- if true then use GZIP compatible compressionpublic Deflater(int level)
level
- the compression level (0-9)public Deflater()
public void setInput(byte[] input, int off, int len)
One of the setInput()
methods should be called whenever needsInput()
returns true indicating that more input data is required.
input
- the input data bytesoff
- the start offset of the datalen
- the length of the datapublic void setInput(byte[] input)
One of the setInput()
methods should be called whenever needsInput()
returns true indicating that more input data is required.
input
- the input data bytespublic void setInput(ByteBuffer input)
One of the setInput()
methods should be called whenever needsInput()
returns true indicating that more input data is required.
The given buffer's position will be advanced as deflate operations are performed, up to the buffer's limit. The input buffer may be modified (refilled) between deflate operations; doing so is equivalent to creating a new buffer and setting it with this method.
Modifying the input buffer's contents, position, or limit concurrently with an deflate operation will result in undefined behavior, which may include incorrect operation results or operation failure.
input
- the input data bytespublic void setDictionary(byte[] dictionary, int off, int len)
dictionary
- the dictionary data bytesoff
- the start offset of the datalen
- the length of the datapublic void setDictionary(byte[] dictionary)
dictionary
- the dictionary data bytespublic void setDictionary(ByteBuffer dictionary)
The bytes in given byte buffer will be fully consumed by this method. On return, its position will equal its limit.
dictionary
- the dictionary data bytespublic void setStrategy(int strategy)
If the compression strategy is changed, the next invocation of deflate
will compress the input available so far with the old strategy (and may be flushed); the new strategy will take effect only after that invocation.
strategy
- the new compression strategyIllegalArgumentException
- if the compression strategy is invalidpublic void setLevel(int level)
If the compression level is changed, the next invocation of deflate
will compress the input available so far with the old level (and may be flushed); the new level will take effect only after that invocation.
level
- the new compression level (0-9)IllegalArgumentException
- if the compression level is invalidpublic boolean needsInput()
setInput()
methods should be called in order to provide more input.public void finish()
public boolean finished()
public int deflate(byte[] output, int off, int len)
needsInput
should be called in order to determine if more input data is required. This method uses NO_FLUSH
as its compression flush mode. An invocation of this method of the form deflater.deflate(b, off, len)
yields the same result as the invocation of deflater.deflate(b, off, len, Deflater.NO_FLUSH)
.
output
- the buffer for the compressed dataoff
- the start offset of the datalen
- the maximum number of bytes of compressed datapublic int deflate(byte[] output)
needsInput
should be called in order to determine if more input data is required. This method uses NO_FLUSH
as its compression flush mode. An invocation of this method of the form deflater.deflate(b)
yields the same result as the invocation of deflater.deflate(b, 0, b.length, Deflater.NO_FLUSH)
.
output
- the buffer for the compressed datapublic int deflate(ByteBuffer output)
needsInput
should be called in order to determine if more input data is required. This method uses NO_FLUSH
as its compression flush mode. An invocation of this method of the form deflater.deflate(output)
yields the same result as the invocation of deflater.deflate(output, Deflater.NO_FLUSH)
.
output
- the buffer for the compressed dataReadOnlyBufferException
- if the given output buffer is read-onlypublic int deflate(byte[] output, int off, int len, int flush)
Compression flush mode is one of the following three modes:
NO_FLUSH
: allows the deflater to decide how much data to accumulate, before producing output, in order to achieve the best compression (should be used in normal use scenario). A return value of 0 in this flush mode indicates that needsInput()
should be called in order to determine if more input data is required. SYNC_FLUSH
: all pending output in the deflater is flushed, to the specified output buffer, so that an inflater that works on compressed data can get all input data available so far (In particular the needsInput()
returns true
after this invocation if enough output space is provided). Flushing with SYNC_FLUSH
may degrade compression for some compression algorithms and so it should be used only when necessary. FULL_FLUSH
: all pending output is flushed out as with SYNC_FLUSH
. The compression state is reset so that the inflater that works on the compressed output data can restart from this point if previous compressed data has been damaged or if random access is desired. Using FULL_FLUSH
too often can seriously degrade compression. In the case of FULL_FLUSH
or SYNC_FLUSH
, if the return value is len
, the space available in output buffer b
, this method should be invoked again with the same flush
parameter and more output space. Make sure that len
is greater than 6 to avoid flush marker (5 bytes) being repeatedly output to the output buffer every time this method is invoked.
If the setInput(ByteBuffer)
method was called to provide a buffer for input, the input buffer's position will be advanced by the number of bytes consumed by this operation.
output
- the buffer for the compressed dataoff
- the start offset of the datalen
- the maximum number of bytes of compressed dataflush
- the compression flush modeIllegalArgumentException
- if the flush mode is invalidpublic int deflate(ByteBuffer output, int flush)
Compression flush mode is one of the following three modes:
NO_FLUSH
: allows the deflater to decide how much data to accumulate, before producing output, in order to achieve the best compression (should be used in normal use scenario). A return value of 0 in this flush mode indicates that needsInput()
should be called in order to determine if more input data is required. SYNC_FLUSH
: all pending output in the deflater is flushed, to the specified output buffer, so that an inflater that works on compressed data can get all input data available so far (In particular the needsInput()
returns true
after this invocation if enough output space is provided). Flushing with SYNC_FLUSH
may degrade compression for some compression algorithms and so it should be used only when necessary. FULL_FLUSH
: all pending output is flushed out as with SYNC_FLUSH
. The compression state is reset so that the inflater that works on the compressed output data can restart from this point if previous compressed data has been damaged or if random access is desired. Using FULL_FLUSH
too often can seriously degrade compression. In the case of FULL_FLUSH
or SYNC_FLUSH
, if the return value is equal to the remaining space of the buffer, this method should be invoked again with the same flush
parameter and more output space. Make sure that the buffer has at least 6 bytes of remaining space to avoid the flush marker (5 bytes) being repeatedly output to the output buffer every time this method is invoked.
On success, the position of the given output
byte buffer will be advanced by as many bytes as were produced by the operation, which is equal to the number returned by this method.
If the setInput(ByteBuffer)
method was called to provide a buffer for input, the input buffer's position will be advanced by the number of bytes consumed by this operation.
output
- the buffer for the compressed dataflush
- the compression flush modeIllegalArgumentException
- if the flush mode is invalidReadOnlyBufferException
- if the given output buffer is read-onlypublic int getAdler()
public int getTotalIn()
Since the number of bytes may be greater than Integer.MAX_VALUE, the getBytesRead()
method is now the preferred means of obtaining this information.
public long getBytesRead()
public int getTotalOut()
Since the number of bytes may be greater than Integer.MAX_VALUE, the getBytesWritten()
method is now the preferred means of obtaining this information.
public long getBytesWritten()
public void reset()
public void end()
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/zip/Deflater.html