Java tutorial
/* * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util.zip; import java.io.FilterInputStream; import java.io.InputStream; import java.io.IOException; /** * Implements an input stream filter for compressing data in the "deflate" * compression format. * * @since 1.6 * @author David R Tribble (david@tribble.com) * * @see DeflaterOutputStream * @see InflaterOutputStream * @see InflaterInputStream */ public class DeflaterInputStream extends FilterInputStream { /** Compressor for this stream. */ protected final Deflater def; /** Input buffer for reading compressed data. */ protected final byte[] buf; /** Temporary read buffer. */ private byte[] rbuf = new byte[1]; /** Default compressor is used. */ private boolean usesDefaultDeflater = false; /** End of the underlying input stream has been reached. */ private boolean reachEOF = false; /** * Check to make sure that this stream has not been closed. */ private void ensureOpen() throws IOException { if (in == null) { throw new IOException("Stream closed"); } } /** * 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 */ public DeflaterInputStream(InputStream in) { this(in, new Deflater()); usesDefaultDeflater = true; } /** * 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 */ public DeflaterInputStream(InputStream in, Deflater defl) { this(in, defl, 512); } /** * 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 <= 0} * @throws NullPointerException if {@code in} or {@code defl} is null */ public DeflaterInputStream(InputStream in, Deflater defl, int bufLen) { 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]; } /** * Closes this input stream and its underlying input stream, discarding * any pending uncompressed data. * * @throws IOException if an I/O error occurs */ public void close() throws IOException { if (in != null) { try { // Clean up if (usesDefaultDeflater) { def.end(); } in.close(); } finally { in = null; } } } /** * 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 */ public int read() throws IOException { // Read a single byte of compressed data int len = read(rbuf, 0, 1); if (len <= 0) return -1; return (rbuf[0] & 0xFF); } /** * 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 > b.length - off} * @throws IOException if an I/O error occurs or if this input stream is * already closed */ public int read(byte[] b, int off, int len) throws IOException { // 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; } /** * Skips over and discards data from the input stream. * This method may block until the specified number of bytes are read and * skipped. <em>Note:</em> 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 */ public long skip(long n) throws IOException { 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; } /** * Returns 0 after EOF has been reached, otherwise always return 1. * <p> * 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 */ public int available() throws IOException { ensureOpen(); if (reachEOF) { return 0; } return 1; } /** * Always returns {@code false} because this input stream does not support * the {@link #mark mark()} and {@link #reset reset()} methods. * * @return false, always */ public boolean markSupported() { return false; } /** * <i>This operation is not supported</i>. * * @param limit maximum bytes that can be read before invalidating the position marker */ public void mark(int limit) { // Operation not supported } /** * <i>This operation is not supported</i>. * * @throws IOException always thrown */ public void reset() throws IOException { throw new IOException("mark/reset not supported"); } }