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\u20AC\u20AC";
* 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
* }
* This method uses {@link #NO_FLUSH} as its compression flush mode. * An invocation of this method of the form {@code deflater.deflate(b, off, len)} * yields the same result as the invocation of * {@code deflater.deflate(b, off, len, Deflater.NO_FLUSH)}. * * @param b the buffer for the compressed data * @param off the start offset of the data * @param len the maximum number of bytes of compressed data * @return the actual number of bytes of compressed data written to the * output buffer */ public int deflate(byte[] b, int off, int len) { return deflate(b, off, len, NO_FLUSH); } /** * Compresses the input data and fills specified buffer with compressed * data. Returns actual number of bytes of compressed data. A return value * of 0 indicates that {@link needsInput() needsInput} should be called * in order to determine if more input data is required. * *
This method uses {@link #NO_FLUSH} as its compression flush mode. * An invocation of this method of the form {@code deflater.deflate(b)} * yields the same result as the invocation of * {@code deflater.deflate(b, 0, b.length, Deflater.NO_FLUSH)}. * * @param b the buffer for the compressed data * @return the actual number of bytes of compressed data written to the * output buffer */ public int deflate(byte[] b) { return deflate(b, 0, b.length, NO_FLUSH); } /** * Compresses the input data and fills the specified buffer with compressed * data. Returns actual number of bytes of data compressed. * *
Compression flush mode is one of the following three modes: * *
In the case of {@link #FULL_FLUSH} or {@link #SYNC_FLUSH}, if * the return value is {@code len}, the space available in output * buffer {@code b}, this method should be invoked again with the same * {@code flush} parameter and more output space. * * @param b the buffer for the compressed data * @param off the start offset of the data * @param len the maximum number of bytes of compressed data * @param flush the compression flush mode * @return the actual number of bytes of compressed data written to * the output buffer * * @throws IllegalArgumentException if the flush mode is invalid * @since 1.7 */ public synchronized int deflate(byte[] b, int off, int len, int flush) { if (b == null) { throw new NullPointerException(); } if (off < 0 || len < 0 || off > b.length - len) { throw new ArrayIndexOutOfBoundsException(); } if (flush == NO_FLUSH || flush == SYNC_FLUSH || flush == FULL_FLUSH) return deflateBytes(b, off, len, flush); throw new IllegalArgumentException(); } /** * Returns the ADLER-32 value of the uncompressed data. * @return the ADLER-32 value of the uncompressed data */ public synchronized int getAdler() { ensureOpen(); return getAdler(strm); } /** * Returns the total number of uncompressed bytes input so far. * *
Since the number of bytes may be greater than * Integer.MAX_VALUE, the {@link #getBytesRead()} method is now * the preferred means of obtaining this information.
* * @return the total number of uncompressed bytes input so far */ public int getTotalIn() { return (int) getBytesRead(); } /** * Returns the total number of uncompressed bytes input so far. * * @return the total (non-negative) number of uncompressed bytes input so far * @since 1.5 */ public synchronized long getBytesRead() { ensureOpen(); return getBytesRead(strm); } /** * Returns the total number of compressed bytes output so far. * *Since the number of bytes may be greater than * Integer.MAX_VALUE, the {@link #getBytesWritten()} method is now * the preferred means of obtaining this information.
* * @return the total number of compressed bytes output so far */ public int getTotalOut() { return (int) getBytesWritten(); } /** * Returns the total number of compressed bytes output so far. * * @return the total (non-negative) number of compressed bytes output so far * @since 1.5 */ public synchronized long getBytesWritten() { ensureOpen(); return getBytesWritten(strm); } /** * Resets deflater so that a new set of input data can be processed. * Keeps current compression level and strategy settings. */ public synchronized void reset() { ensureOpen(); reset(strm); finish = false; finished = false; off = len = 0; } /** * Closes the compressor and discards any unprocessed input. * This method should be called when the compressor is no longer * being used, but will also be called automatically by the * finalize() method. Once this method is called, the behavior * of the Deflater object is undefined. */ public synchronized void end() { if (strm != 0) { end(strm); strm = 0; buf = null; } } /** * Closes the compressor when garbage is collected. */ protected void finalize() { end(); } private void ensureOpen() { if (strm == 0) throw new NullPointerException(); } private static native void initIDs(); private native static long init(int level, int strategy, boolean nowrap); private native static void setDictionary(long strm, byte[] b, int off, int len); private native int deflateBytes(byte[] b, int off, int len, int flush); private native static int getAdler(long strm); private native static long getBytesRead(long strm); private native static long getBytesWritten(long strm); private native static void reset(long strm); private native static void end(long strm); }