IT. Expert System.

Android Reference

Deflater


java.util.zip

Class Deflater



  • public class Deflater
    extends Object
    This class compresses data using the DEFLATE algorithm (see specification).

    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.

    • Field Summary

      Fields
      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 Summary

      Constructors
      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.
    • Method Summary

      Methods
      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()
      Returns true if finish has been called and all data provided by setInput has been successfully compressed and consumed by deflate.
      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.
    • Field Detail

      • BEST_COMPRESSION

        public static final int BEST_COMPRESSION
        Upper bound for the compression level range.
        See Also:
        Constant Field Values
      • BEST_SPEED

        public static final int BEST_SPEED
        Lower bound for compression level range.
        See Also:
        Constant Field Values
      • DEFAULT_COMPRESSION

        public static final int DEFAULT_COMPRESSION
        The default compression level.
        See Also:
        Constant Field Values
      • DEFAULT_STRATEGY

        public static final int DEFAULT_STRATEGY
        The default compression strategy.
        See Also:
        Constant Field Values
      • DEFLATED

        public static final int DEFLATED
        The default compression method.
        See Also:
        Constant Field Values
      • HUFFMAN_ONLY

        public static final int HUFFMAN_ONLY
        A compression strategy.
        See Also:
        Constant Field Values
      • NO_COMPRESSION

        public static final int NO_COMPRESSION
        A compression level.
        See Also:
        Constant Field Values
      • NO_FLUSH

        public static final int NO_FLUSH
        Use buffering for best compression.
        Since:
        1.7
        See Also:
        Constant Field Values
      • SYNC_FLUSH

        public static final int SYNC_FLUSH
        Flush buffers so recipients can immediately decode the data sent thus far. This mode may degrade compression.
        Since:
        1.7
        See Also:
        Constant Field Values
      • FULL_FLUSH

        public static final int FULL_FLUSH
        Flush buffers so recipients can immediately decode the data sent thus far. The compression state is also reset to permit random access and recovery for clients who have discarded or damaged their own copy. This mode may degrade compression.
        Since:
        1.7
        See Also:
        Constant Field Values
    • Constructor Detail

      • Deflater

        public Deflater()
        Constructs a new 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.
      • Deflater

        public Deflater(int level)
        Constructs a new 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.
        Parameters:
        level - the compression level in the range between 0 and 9.
      • Deflater

        public Deflater(int level,
                boolean noHeader)
        Constructs a new 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).
        Parameters:
        level - the compression level in the range between 0 and 9.
        noHeader - true indicates that no ZLIB header should be written.
    • Method Detail

      • deflate

        public int deflate(byte[] buf)
        Deflates the data (previously passed to setInput) into the supplied buffer.
        Returns:
        number of bytes of compressed data written to buf.
      • deflate

        public int deflate(byte[] buf,
                  int offset,
                  int byteCount)
        Deflates data (previously passed to setInput) into a specific region within the supplied buffer.
        Returns:
        the number of bytes of compressed data written to buf.
      • deflate

        public 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.
        Parameters:
        flush - one of NO_FLUSH, SYNC_FLUSH or FULL_FLUSH.
        Returns:
        the number of compressed bytes written to 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.
        Since:
        1.7
      • end

        public void end()
        Frees all resources held onto by this deflating algorithm. Any unused input or output is discarded. This method should be called explicitly in order to free native resources as soon as possible. After end() is called, other methods will typically throw IllegalStateException.
      • finalize

        protected void finalize()
        Description copied from class: Object
        Invoked when the garbage collector has detected that this instance is no longer reachable. The default implementation does nothing, but this method can be overridden to free resources.

        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.

        Overrides:
        finalize in class Object
      • finish

        public void finish()
        Indicates to the Deflater that all uncompressed input has been provided to it.
        See Also:
        finished
      • finished

        public boolean finished()
        Returns true if finish has been called and all data provided by setInput has been successfully compressed and consumed by deflate.
      • getAdler

        public int getAdler()
        Returns the Adler32 checksum of the uncompressed data read so far.
      • getTotalIn

        public int getTotalIn()
        Returns the total number of bytes of input read by this Deflater. This method is limited to 32 bits; use getBytesRead() instead.
      • getTotalOut

        public int getTotalOut()
        Returns the total number of bytes written to the output buffer by this Deflater. The method is limited to 32 bits; use getBytesWritten() instead.
      • needsInput

        public boolean needsInput()
        Returns true if setInput must be called before deflation can continue. If all uncompressed data has been provided to the Deflater, finish() must be called to ensure the compressed data is output.
      • reset

        public void reset()
        Resets the 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.
      • setDictionary

        public void setDictionary(byte[] dictionary)
        Sets the dictionary to be used for compression by this 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).
      • setDictionary

        public void setDictionary(byte[] buf,
                         int offset,
                         int byteCount)
        Sets the dictionary to be used for compression by this 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).
      • setInput

        public void setInput(byte[] buf)
        Sets the input buffer the Deflater will use to extract uncompressed bytes for later compression.
      • setInput

        public void setInput(byte[] buf,
                    int offset,
                    int byteCount)
        Sets the input buffer the Deflater will use to extract uncompressed bytes for later compression.
      • setLevel

        public void setLevel(int level)
        Sets the compression level to be used when compressing data. The compression level must be a value between 0 and 9. This value must be set prior to calling setInput.
        Throws:
        IllegalArgumentException - If the compression level is invalid.
      • setStrategy

        public void setStrategy(int strategy)
        Sets the compression strategy to be used. The strategy must be one of FILTERED, HUFFMAN_ONLY or DEFAULT_STRATEGY. This value must be set prior to calling setInput.
        Throws:
        IllegalArgumentException - If the strategy specified is not one of FILTERED, HUFFMAN_ONLY or DEFAULT_STRATEGY.
      • getBytesRead

        public long getBytesRead()
        Returns the total number of bytes read by the Deflater. This method is the same as getTotalIn() except that it returns a long value instead of an integer.
      • getBytesWritten

        public long getBytesWritten()
        Returns a the total number of bytes written by this Deflater. This method is the same as getTotalOut except it returns a long value instead of an integer.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 149 / 158749501. Delta: 0.03867 с