public class Deflater extends Object
It is usually more convenient to use DeflaterOutputStream
.
To compress an in-memory byte[]
to another in-memory byte[]
manually:
byte[] originalBytes = ... Deflater deflater = new Deflater(); deflater.setInput(originalBytes); deflater.finish(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); byte[] buf = new byte[8192]; while (!deflater.finished()) { int byteCount = deflater.deflate(buf); baos.write(buf, 0, byteCount); } deflater.end(); byte[] compressedBytes = baos.toByteArray();
In situations where you don't have all the input in one array (or have so much
input that you want to feed it to the deflater in chunks), it's possible to call
setInput
repeatedly, but you're much better off using
DeflaterOutputStream
to handle all this for you. DeflaterOutputStream
also helps
minimize memory requirements — the sample code above is very expensive.
Modifier and Type | Field and Description |
---|---|
static int |
BEST_COMPRESSION
Upper bound for the compression level range.
|
static int |
BEST_SPEED
Lower bound for compression level range.
|
static int |
DEFAULT_COMPRESSION
The default compression level.
|
static int |
DEFAULT_STRATEGY
The default compression strategy.
|
static int |
DEFLATED
The default compression method.
|
static int |
FILTERED
A compression strategy.
|
static int |
FULL_FLUSH
Flush buffers so recipients can immediately decode the data sent thus
far.
|
static int |
HUFFMAN_ONLY
A compression strategy.
|
static int |
NO_COMPRESSION
A compression level.
|
static int |
NO_FLUSH
Use buffering for best compression.
|
static int |
SYNC_FLUSH
Flush buffers so recipients can immediately decode the data sent thus
far.
|
Constructor and Description |
---|
Deflater()
Constructs a new
Deflater instance using the default compression
level. |
Deflater(int level)
Constructs a new
Deflater instance using compression
level level . |
Deflater(int level,
boolean noHeader)
Constructs a new
Deflater instance with a specific compression
level. |
Modifier and Type | Method and Description |
---|---|
int |
deflate(byte[] buf)
Deflates the data (previously passed to
setInput ) into the
supplied buffer. |
int |
deflate(byte[] buf,
int offset,
int byteCount)
Deflates data (previously passed to
setInput ) into a specific
region within the supplied buffer. |
int |
deflate(byte[] buf,
int offset,
int byteCount,
int flush)
Deflates data (previously passed to
setInput ) into a specific
region within the supplied buffer, optionally flushing the input buffer. |
void |
end()
Frees all resources held onto by this deflating algorithm.
|
protected void |
finalize()
Invoked when the garbage collector has detected that this instance is no longer reachable.
|
void |
finish()
Indicates to the
Deflater that all uncompressed input has been provided
to it. |
boolean |
finished()
|
int |
getAdler()
Returns the
Adler32 checksum of the uncompressed data read so far. |
long |
getBytesRead()
Returns the total number of bytes read by the
Deflater . |
long |
getBytesWritten()
Returns a the total number of bytes written by this
Deflater . |
int |
getTotalIn()
Returns the total number of bytes of input read by this
Deflater . |
int |
getTotalOut()
Returns the total number of bytes written to the output buffer by this
Deflater . |
boolean |
needsInput()
Returns true if
setInput must be called before deflation can continue. |
void |
reset()
Resets the
Deflater to accept new input without affecting any
previously made settings for the compression strategy or level. |
void |
setDictionary(byte[] dictionary)
Sets the dictionary to be used for compression by this
Deflater . |
void |
setDictionary(byte[] buf,
int offset,
int byteCount)
Sets the dictionary to be used for compression by this
Deflater . |
void |
setInput(byte[] buf)
Sets the input buffer the
Deflater will use to extract uncompressed bytes
for later compression. |
void |
setInput(byte[] buf,
int offset,
int byteCount)
Sets the input buffer the
Deflater will use to extract uncompressed bytes
for later compression. |
void |
setLevel(int level)
Sets the compression level to be used when compressing data.
|
void |
setStrategy(int strategy)
Sets the compression strategy to be used.
|
public static final int BEST_COMPRESSION
public static final int BEST_SPEED
public static final int DEFAULT_COMPRESSION
public static final int DEFAULT_STRATEGY
public static final int DEFLATED
public static final int FILTERED
public static final int HUFFMAN_ONLY
public static final int NO_COMPRESSION
public static final int NO_FLUSH
public static final int SYNC_FLUSH
public static final int FULL_FLUSH
public Deflater()
Deflater
instance using the default compression
level. The strategy can be specified with setStrategy(int)
. A
header is added to the output by default; use Deflater(int, boolean)
if you need to omit the header.public Deflater(int level)
Deflater
instance using compression
level level
. The strategy can be specified with setStrategy(int)
.
A header is added to the output by default; use
Deflater(int, boolean)
if you need to omit the header.level
- the compression level in the range between 0 and 9.public Deflater(int level, boolean noHeader)
Deflater
instance with a specific compression
level. If noHeader
is true, no ZLIB header is added to the
output. In a ZIP archive every entry (compressed file) comes with such a
header. The strategy can be specified using setStrategy(int)
.level
- the compression level in the range between 0 and 9.noHeader
- true
indicates that no ZLIB header should be written.public int deflate(byte[] buf)
setInput
) into the
supplied buffer.buf
.public int deflate(byte[] buf, int offset, int byteCount)
setInput
) into a specific
region within the supplied buffer.buf
.public int deflate(byte[] buf, int offset, int byteCount, int flush)
setInput
) into a specific
region within the supplied buffer, optionally flushing the input buffer.flush
- one of NO_FLUSH
, SYNC_FLUSH
or FULL_FLUSH
.buf
. If this
equals byteCount
, the number of bytes of input to be flushed
may have exceeded the output buffer's capacity. In this case,
finishing a flush will require the output buffer to be drained
and additional calls to deflate(byte[])
to be made.public void end()
end()
is
called, other methods will typically throw IllegalStateException
.protected void finalize()
Object
Note that objects that override finalize
are significantly more expensive than
objects that don't. Finalizers may be run a long time after the object is no longer
reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup.
Note also that finalizers are run on a single VM-wide finalizer thread,
so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary
for a class that has a native peer and needs to call a native method to destroy that peer.
Even then, it's better to provide an explicit close
method (and implement
Closeable
), and insist that callers manually dispose of instances. This
works well for something like files, but less well for something like a BigInteger
where typical calling code would have to deal with lots of temporaries. Unfortunately,
code that creates lots of temporaries is the worst kind of code from the point of view of
the single finalizer thread.
If you must use finalizers, consider at least providing your own
ReferenceQueue
and having your own thread process that queue.
Unlike constructors, finalizers are not automatically chained. You are responsible for
calling super.finalize()
yourself.
Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread. See Effective Java Item 7, "Avoid finalizers" for more.
public void finish()
Deflater
that all uncompressed input has been provided
to it.finished
public boolean finished()
public int getAdler()
Adler32
checksum of the uncompressed data read so far.public int getTotalIn()
Deflater
. This
method is limited to 32 bits; use getBytesRead()
instead.public int getTotalOut()
Deflater
. The method is limited to 32 bits; use getBytesWritten()
instead.public boolean needsInput()
public void reset()
Deflater
to accept new input without affecting any
previously made settings for the compression strategy or level. This
operation must be called after finished
returns
true if the Deflater
is to be reused.public void setDictionary(byte[] dictionary)
Deflater
.
This method can only be called if this Deflater
supports the writing
of ZLIB headers. This is the default, but can be overridden
using Deflater(int, boolean)
.public void setDictionary(byte[] buf, int offset, int byteCount)
Deflater
.
This method can only be called if this Deflater
supports the writing
of ZLIB headers. This is the default, but can be overridden
using Deflater(int, boolean)
.public void setInput(byte[] buf)
Deflater
will use to extract uncompressed bytes
for later compression.public void setInput(byte[] buf, int offset, int byteCount)
Deflater
will use to extract uncompressed bytes
for later compression.public void setLevel(int level)
setInput
.IllegalArgumentException
- If the compression level is invalid.public void setStrategy(int strategy)
setInput
.IllegalArgumentException
- If the strategy specified is not one of FILTERED,
HUFFMAN_ONLY or DEFAULT_STRATEGY.public long getBytesRead()
Deflater
. This
method is the same as getTotalIn()
except that it returns a
long
value instead of an integer.public long getBytesWritten()
Deflater
. This
method is the same as getTotalOut
except it returns a
long
value instead of an integer.