FileDocCategorySizeDatePackage
DeflaterInputStream.javaAPI DocJava SE 6 API8418Tue Jun 10 00:26:00 BST 2008java.util.zip

DeflaterInputStream

public class DeflaterInputStream extends FilterInputStream
Implements an input stream filter for compressing data in the "deflate" compression format.
version
1.1
since
1.6
author
David R Tribble (david@tribble.com)
see
DeflaterOutputStream
see
InflaterOutputStream
see
InflaterInputStream

Fields Summary
protected final Deflater
def
Compressor for this stream.
protected final byte[]
buf
Input buffer for reading compressed data.
private byte[]
rbuf
Temporary read buffer.
private boolean
usesDefaultDeflater
Default compressor is used.
private boolean
reachEOF
End of the underlying input stream has been reached.
Constructors Summary
public DeflaterInputStream(InputStream in)
Creates a new input stream with a default compressor and buffer size.

param
in input stream to read the uncompressed data to
throws
NullPointerException if {@code in} is null

        this(in, new Deflater());
        usesDefaultDeflater = true;
    
public DeflaterInputStream(InputStream in, Deflater defl)
Creates a new input stream with the specified compressor and a default buffer size.

param
in input stream to read the uncompressed data to
param
defl compressor ("deflater") for this stream
throws
NullPointerException if {@code in} or {@code defl} is null

        this(in, defl, 512);
    
public DeflaterInputStream(InputStream in, Deflater defl, int bufLen)
Creates a new input stream with the specified compressor and buffer size.

param
in input stream to read the uncompressed data to
param
defl compressor ("deflater") for this stream
param
bufLen compression buffer size
throws
IllegalArgumentException if {@code bufLen} is <= 0
throws
NullPointerException if {@code in} or {@code defl} is null

        super(in);

        // Sanity checks
        if (in == null)
            throw new NullPointerException("Null input");
        if (defl == null)
            throw new NullPointerException("Null deflater");
        if (bufLen < 1)
            throw new IllegalArgumentException("Buffer size < 1");

        // Initialize
        def = defl;
        buf = new byte[bufLen];
    
Methods Summary
public intavailable()
Returns 0 after EOF has been reached, otherwise always return 1.

Programs should not count on this method to return the actual number of bytes that could be read without blocking

return
zero after the end of the underlying input stream has been reached, otherwise always returns 1
throws
IOException if an I/O error occurs or if this stream is already closed

        ensureOpen();
        if (reachEOF) {
            return 0;
        }
        return 1;
    
public voidclose()
Closes this input stream and its underlying input stream, discarding any pending uncompressed data.

throws
IOException if an I/O error occurs

        if (in != null) {
            try {
                // Clean up
                if (usesDefaultDeflater) {
                    def.end();
                }

                in.close();
            } finally {
                in = null;
            }
        }
    
private voidensureOpen()
Check to make sure that this stream has not been closed.


                    
         
        if (in == null) {
            throw new IOException("Stream closed");
        }
    
public voidmark(int limit)
This operation is not supported.

param
limit maximum bytes that can be read before invalidating the position marker

        // Operation not supported
    
public booleanmarkSupported()
Always returns {@code false} because this input stream does not support the {@link #mark mark()} and {@link #reset reset()} methods.

return
false, always

        return false;
    
public intread()
Reads a single byte of compressed data from the input stream. This method will block until some input can be read and compressed.

return
a single byte of compressed data, or -1 if the end of the uncompressed input stream is reached
throws
IOException if an I/O error occurs or if this stream is already closed

        // Read a single byte of compressed data
        int len = read(rbuf, 0, 1);
        if (len <= 0)
            return -1;
        return (rbuf[0] & 0xFF);
    
public intread(byte[] b, int off, int len)
Reads compressed data into a byte array. This method will block until some input can be read and compressed.

param
b buffer into which the data is read
param
off starting offset of the data within {@code b}
param
len maximum number of compressed bytes to read into {@code b}
return
the actual number of bytes read, or -1 if the end of the uncompressed input stream is reached
throws
IndexOutOfBoundsException if {@code len} > {@code b.length - off}
throws
IOException if an I/O error occurs or if this input stream is already closed

        // Sanity checks
        ensureOpen();
        if (b == null) {
            throw new NullPointerException("Null buffer for read");
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        // Read and compress (deflate) input data bytes
        int cnt = 0;
        while (len > 0 && !def.finished()) {
            int n;

            // Read data from the input stream
            if (def.needsInput()) {
                n = in.read(buf, 0, buf.length);
                if (n < 0) {
                    // End of the input stream reached
                    def.finish();
                } else if (n > 0) {
                    def.setInput(buf, 0, n);
                }
            }

            // Compress the input data, filling the read buffer
            n = def.deflate(b, off, len);
            cnt += n;
            off += n;
            len -= n;
        }
        if (cnt == 0 && def.finished()) {
            reachEOF = true;
            cnt = -1;
        }

        return cnt;
    
public voidreset()
This operation is not supported.

throws
IOException always thrown

        throw new IOException("mark/reset not supported");
    
public longskip(long n)
Skips over and discards data from the input stream. This method may block until the specified number of bytes are read and skipped. Note: While {@code n} is given as a {@code long}, the maximum number of bytes which can be skipped is {@code Integer.MAX_VALUE}.

param
n number of bytes to be skipped
return
the actual number of bytes skipped
throws
IOException if an I/O error occurs or if this stream is already closed

        if (n < 0) {
            throw new IllegalArgumentException("negative skip length");
        }
        ensureOpen();

        // Skip bytes by repeatedly decompressing small blocks
        if (rbuf.length < 512)
            rbuf = new byte[512];

        int total = (int)Math.min(n, Integer.MAX_VALUE);
        long cnt = 0;
        while (total > 0) {
            // Read a small block of uncompressed bytes
            int len = read(rbuf, 0, (total <= rbuf.length ? total : rbuf.length));

            if (len < 0) {
                break;
            }
            cnt += len;
            total -= len;
        }
        return cnt;