Java/File Input Output/GZIP
Содержание
- 1 A collection of utility methods for working on GZIPed data
- 2 Compress a file in the GZIP format
- 3 Compress a list of files passed in from command line
- 4 Compressed socket
- 5 Compressing a File
- 6 Compressing a File in the GZIP Format
- 7 Compress Java objects
- 8 Decompress Java objects
- 9 GZIP compress
- 10 GZIP Filter, response stream and Response Wrapper
- 11 gzipping files and zipping directories
- 12 GZip with GZIPOutputStream
- 13 Reads GZIP, Zip, and Jar files
- 14 Read some data from a gzip file
- 15 Uncompress a file in the GZIP format
- 16 Uncompressing a File in the GZIP Format
- 17 Ungzip with GZIPInputStream
A collection of utility methods for working on GZIPed data
<source lang="java">
/**
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
import java.io.ByteArrayOutputStream; import java.io.ByteArrayInputStream; import java.io.IOException; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; // Commons Logging imports /**
* A collection of utility methods for working on GZIPed data. */
public class GZIPUtils {
private static final int EXPECTED_COMPRESSION_RATIO= 5; private static final int BUF_SIZE= 4096; /** * Returns an gunzipped copy of the input array. If the gzipped * input has been truncated or corrupted, a best-effort attempt is * made to unzip as much as possible. If no data can be extracted *null
is returned. */ public static final byte[] unzipBestEffort(byte[] in) { return unzipBestEffort(in, Integer.MAX_VALUE); } /** * Returns an gunzipped copy of the input array, truncated to *sizeLimit
bytes, if necessary. If the gzipped input * has been truncated or corrupted, a best-effort attempt is made to * unzip as much as possible. If no data can be extracted *null
is returned. */ public static final byte[] unzipBestEffort(byte[] in, int sizeLimit) { try { // decompress using GZIPInputStream ByteArrayOutputStream outStream = new ByteArrayOutputStream(EXPECTED_COMPRESSION_RATIO * in.length); GZIPInputStream inStream = new GZIPInputStream ( new ByteArrayInputStream(in) ); byte[] buf = new byte[BUF_SIZE]; int written = 0; while (true) { try { int size = inStream.read(buf); if (size <= 0) break; if ((written + size) > sizeLimit) { outStream.write(buf, 0, sizeLimit - written); break; } outStream.write(buf, 0, size); written+= size; } catch (Exception e) { break; } } try { outStream.close(); } catch (IOException e) { } return outStream.toByteArray(); } catch (IOException e) { return null; } }
/** * Returns an gunzipped copy of the input array. * @throws IOException if the input cannot be properly decompressed */ public static final byte[] unzip(byte[] in) throws IOException { // decompress using GZIPInputStream ByteArrayOutputStream outStream = new ByteArrayOutputStream(EXPECTED_COMPRESSION_RATIO * in.length); GZIPInputStream inStream = new GZIPInputStream ( new ByteArrayInputStream(in) ); byte[] buf = new byte[BUF_SIZE]; while (true) { int size = inStream.read(buf); if (size <= 0) break; outStream.write(buf, 0, size); } outStream.close(); return outStream.toByteArray(); } /** * Returns an gzipped copy of the input array. */ public static final byte[] zip(byte[] in) { try { // compress using GZIPOutputStream ByteArrayOutputStream byteOut= new ByteArrayOutputStream(in.length / EXPECTED_COMPRESSION_RATIO); GZIPOutputStream outStream= new GZIPOutputStream(byteOut); try { outStream.write(in); } catch (Exception e) { } try { outStream.close(); } catch (IOException e) { } return byteOut.toByteArray(); } catch (IOException e) { return null; } }
}
</source>
Compress a file in the GZIP format
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.zip.GZIPOutputStream; public class Main {
public static void main(String[] argv) throws Exception { GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream("outfile.gzip")); FileInputStream in = new FileInputStream("infilename"); byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0) { out.write(buf, 0, len); } in.close(); out.finish(); out.close(); }
}
</source>
Compress a list of files passed in from command line
<source lang="java">
import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; import java.util.zip.ZipException; class ZipDemo {
private static final int DEFAULT_BUFFER_SIZE = 4096; public static final byte[] compress(final String uncompressed) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); GZIPOutputStream zos = new GZIPOutputStream(baos); byte[] uncompressedBytes = uncompressed.getBytes(); zos.write(uncompressedBytes, 0, uncompressedBytes.length); zos.close(); return baos.toByteArray(); } public static final String uncompress(final byte[] compressed) throws IOException { String uncompressed = ""; try { ByteArrayInputStream bais = new ByteArrayInputStream(compressed); GZIPInputStream zis = new GZIPInputStream(bais); ByteArrayOutputStream baos = new ByteArrayOutputStream(); int numBytesRead = 0; byte[] tempBytes = new byte[DEFAULT_BUFFER_SIZE]; while ((numBytesRead = zis.read(tempBytes, 0, tempBytes.length)) != -1) { baos.write(tempBytes, 0, numBytesRead); } uncompressed = new String(baos.toByteArray()); } catch (ZipException e) { e.printStackTrace(System.err); } return uncompressed; } public static final String uncompress(final String compressed) throws IOException { return ZipDemo.uncompress(compressed.getBytes()); } public static void main(String[] args) throws Exception{ for (int i = 0; i < args.length; ++i) { String uncompressed = ""; File f = new File(args[i]); if (f.exists()) { BufferedReader br = new BufferedReader(new FileReader(f)); String line = ""; StringBuffer buffer = new StringBuffer(); while ((line = br.readLine()) != null) buffer.append(line); br.close(); uncompressed = buffer.toString(); } else { uncompressed = args[i]; } byte[] compressed = ZipDemo.rupress(uncompressed); String compressedAsString = new String(compressed); byte[] bytesFromCompressedAsString = compressedAsString.getBytes(); bytesFromCompressedAsString.equals(compressed); System.out.println(ZipDemo.uncompress(compressed)); System.out.println(ZipDemo.uncompress(compressedAsString)); } }
}
</source>
Compressed socket
<source lang="java">
import java.net.ServerSocket; import java.net.Socket; import java.util.zip.GZIPInputStream; public class Main {
public static void main(String[] args) throws Exception { ServerSocket ssock = new ServerSocket(Integer.parseInt(args[0])); Socket sock = ssock.accept(); GZIPInputStream zip = new GZIPInputStream(sock.getInputStream()); while (true) { int c; c = zip.read(); if (c == -1) break; System.out.print((char) c); } }
}
</source>
Compressing a File
<source lang="java">
import java.io.BufferedInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.zip.GZIPOutputStream; public class CompressIt {
public static void main(String[] args) { String filename = args[0]; try { File file = new File(filename); int length = (int) file.length(); FileInputStream fis = new FileInputStream(file); BufferedInputStream bis = new BufferedInputStream(fis); ByteArrayOutputStream baos = new ByteArrayOutputStream(length); GZIPOutputStream gos = new GZIPOutputStream(baos); byte[] buffer = new byte[1024]; int bytesRead; while ((bytesRead = bis.read(buffer)) != -1) { gos.write(buffer, 0, bytesRead); } bis.close(); gos.close(); System.out.println("Input Length: " + length); System.out.println("Output Length: " + baos.size()); } catch (FileNotFoundException e) { System.err.println("Invalid Filename"); } catch (IOException e) { System.err.println("I/O Exception"); } }
}
</source>
Compressing a File in the GZIP Format
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.zip.GZIPOutputStream; public class Main {
public static void main(String[] argv) throws Exception { String outFilename = "outfile.gzip"; GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(outFilename)); String inFilename = "infilename"; FileInputStream in = new FileInputStream(inFilename); byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0) { out.write(buf, 0, len); } in.close(); out.finish(); out.close(); }
}
</source>
Compress Java objects
<source lang="java">
import java.io.File; import java.io.FileOutputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.zip.GZIPOutputStream; public class Main {
public static void main(String[] args) throws Exception { User admin = new User(); admin.setId(new Long(1)); User foo = new User(); foo.setId(new Long(2)); ObjectOutputStream oos = new ObjectOutputStream(new GZIPOutputStream(new FileOutputStream(new File("user.dat")))); oos.writeObject(admin); oos.writeObject(foo); oos.flush(); oos.close(); }
} class User implements Serializable {
private Long id; public User() { } public Long getId() { return id; } public void setId(Long id) { this.id = id; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("id=").append(id); return sb.toString(); }
}
</source>
Decompress Java objects
<source lang="java">
import java.io.File; import java.io.FileInputStream; import java.io.ObjectInputStream; import java.io.Serializable; import java.util.zip.GZIPInputStream; public class Main {
public static void main(String[] args) throws Exception { ObjectInputStream ois = new ObjectInputStream(new GZIPInputStream(new FileInputStream(new File( "user.dat")))); User admin = (User) ois.readObject(); User foo = (User) ois.readObject(); ois.close(); System.out.println("Admin = [" + admin + "]"); System.out.println("Foo = [" + foo + "]"); }
} class User implements Serializable { }
</source>
GZIP compress
<source lang="java">
// : c12:GZIPcompress.java // {Args: GZIPcompress.java} // {Clean: test.gz} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; public class GZIPcompress {
// Throw exceptions to console: public static void main(String[] args) throws IOException { if (args.length == 0) { System.out.println("Usage: \nGZIPcompress file\n" + "\tUses GZIP compression to compress " + "the file to test.gz"); System.exit(1); } BufferedReader in = new BufferedReader(new FileReader(args[0])); BufferedOutputStream out = new BufferedOutputStream( new GZIPOutputStream(new FileOutputStream("test.gz"))); System.out.println("Writing file"); int c; while ((c = in.read()) != -1) out.write(c); in.close(); out.close(); System.out.println("Reading file"); BufferedReader in2 = new BufferedReader(new InputStreamReader( new GZIPInputStream(new FileInputStream("test.gz")))); String s; while ((s = in2.readLine()) != null) System.out.println(s); }
} ///:~
</source>
GZIP Filter, response stream and Response Wrapper
<source lang="java">
/*
* Copyright 2003 Jayson Falkner (jayson@jspinsider.ru) * This code is from "Servlets and JavaServer pages; the J2EE Web Tier", * http://www.jspbook.ru. You may freely use the code both commercially * and non-commercially. If you like the code, please pick up a copy of * the book and help support the authors, development of more free code, * and the JSP/Servlet/J2EE community. */
import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.util.zip.GZIPOutputStream; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletOutputStream; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponseWrapper; public class GZIPFilter implements Filter {
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { if (req instanceof HttpServletRequest) { HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) res; String ae = request.getHeader("accept-encoding"); if (ae != null && ae.indexOf("gzip") != -1) { GZIPResponseWrapper wrappedResponse = new GZIPResponseWrapper(response); chain.doFilter(req, wrappedResponse); wrappedResponse.finishResponse(); return; } chain.doFilter(req, res); } } public void init(FilterConfig filterConfig) { // noop } public void destroy() { // noop }
} /*
* Copyright 2003 Jayson Falkner (jayson@jspinsider.ru) * This code is from "Servlets and JavaServer pages; the J2EE Web Tier", * http://www.jspbook.ru. You may freely use the code both commercially * and non-commercially. If you like the code, please pick up a copy of * the book and help support the authors, development of more free code, * and the JSP/Servlet/J2EE community. */
class GZIPResponseStream extends ServletOutputStream {
protected ByteArrayOutputStream baos = null; protected GZIPOutputStream gzipstream = null; protected boolean closed = false; protected HttpServletResponse response = null; protected ServletOutputStream output = null; public GZIPResponseStream(HttpServletResponse response) throws IOException { super(); closed = false; this.response = response; this.output = response.getOutputStream(); baos = new ByteArrayOutputStream(); gzipstream = new GZIPOutputStream(baos); } public void close() throws IOException { if (closed) { throw new IOException("This output stream has already been closed"); } gzipstream.finish(); byte[] bytes = baos.toByteArray();
response.addHeader("Content-Length", Integer.toString(bytes.length)); response.addHeader("Content-Encoding", "gzip"); output.write(bytes); output.flush(); output.close(); closed = true; } public void flush() throws IOException { if (closed) { throw new IOException("Cannot flush a closed output stream"); } gzipstream.flush(); } public void write(int b) throws IOException { if (closed) { throw new IOException("Cannot write to a closed output stream"); } gzipstream.write((byte)b); } public void write(byte b[]) throws IOException { write(b, 0, b.length); } public void write(byte b[], int off, int len) throws IOException { if (closed) { throw new IOException("Cannot write to a closed output stream"); } gzipstream.write(b, off, len); } public boolean closed() { return (this.closed); } public void reset() { //noop }
} /*
* Copyright 2003 Jayson Falkner (jayson@jspinsider.ru) * This code is from "Servlets and JavaServer pages; the J2EE Web Tier", * http://www.jspbook.ru. You may freely use the code both commercially * and non-commercially. If you like the code, please pick up a copy of * the book and help support the authors, development of more free code, * and the JSP/Servlet/J2EE community. */ class GZIPResponseWrapper extends HttpServletResponseWrapper { protected HttpServletResponse origResponse = null; protected ServletOutputStream stream = null; protected PrintWriter writer = null; public GZIPResponseWrapper(HttpServletResponse response) { super(response); origResponse = response; } public ServletOutputStream createOutputStream() throws IOException { return (new GZIPResponseStream(origResponse)); } public void finishResponse() { try { if (writer != null) { writer.close(); } else { if (stream != null) { stream.close(); } } } catch (IOException e) {} } public void flushBuffer() throws IOException { stream.flush(); } public ServletOutputStream getOutputStream() throws IOException { if (writer != null) { throw new IllegalStateException("getWriter() has already been called!"); } if (stream == null) stream = createOutputStream(); return (stream); } public PrintWriter getWriter() throws IOException { if (writer != null) { return (writer); } if (stream != null) { throw new IllegalStateException("getOutputStream() has already been called!"); } stream = createOutputStream(); writer = new PrintWriter(new OutputStreamWriter(stream, "UTF-8")); return (writer); } public void setContentLength(int length) {}
}
</source>
gzipping files and zipping directories
<source lang="java">
/*
* Copyright (c) 2004 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 3nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose, * including teaching and use in open-source projects. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book, * please visit http://www.davidflanagan.ru/javaexamples3. */
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.zip.GZIPOutputStream; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; /**
* This class defines two static methods for gzipping files and zipping * directories. It also defines a demonstration program as a nested class. */
public class Compress {
/** Gzip the contents of the from file and save in the to file. */ public static void gzipFile(String from, String to) throws IOException { // Create stream to read from the from file FileInputStream in = new FileInputStream(from); // Create stream to compress data and write it to the to file. GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(to)); // Copy bytes from one stream to the other byte[] buffer = new byte[4096]; int bytes_read; while ((bytes_read = in.read(buffer)) != -1) out.write(buffer, 0, bytes_read); // And close the streams in.close(); out.close(); } /** Zip the contents of the directory, and save it in the zipfile */ public static void zipDirectory(String dir, String zipfile) throws IOException, IllegalArgumentException { // Check that the directory is a directory, and get its contents File d = new File(dir); if (!d.isDirectory()) throw new IllegalArgumentException("Compress: not a directory: " + dir); String[] entries = d.list(); byte[] buffer = new byte[4096]; // Create a buffer for copying int bytes_read; // Create a stream to compress data and write it to the zipfile ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipfile)); // Loop through all entries in the directory for (int i = 0; i < entries.length; i++) { File f = new File(d, entries[i]); if (f.isDirectory()) continue; // Don"t zip sub-directories FileInputStream in = new FileInputStream(f); // Stream to read file ZipEntry entry = new ZipEntry(f.getPath()); // Make a ZipEntry out.putNextEntry(entry); // Store entry while ((bytes_read = in.read(buffer)) != -1) // Copy bytes out.write(buffer, 0, bytes_read); in.close(); // Close input stream } // When we"re done with the whole loop, close the output stream out.close(); } /** * This nested class is a test program that demonstrates the use of the static * methods defined above. */ public static class Test { /** * Compress a specified file or directory. If no destination name is * specified, append .gz to a file name or .zip to a directory name */ public static void main(String args[]) throws IOException { if ((args.length != 1) && (args.length != 2)) { // check arguments System.err.println("Usage: java Compress$Test <from> [<to>]"); System.exit(0); } String from = args[0], to; File f = new File(from); boolean directory = f.isDirectory(); // Is it a file or directory? if (args.length == 2) to = args[1]; else { // If destination not specified if (directory) to = from + ".zip"; // use a .zip suffix else to = from + ".gz"; // or a .gz suffix } if ((new File(to)).exists()) { // Make sure not to overwrite System.err.println("Compress: won"t overwrite existing file: " + to); System.exit(0); } // Finally, call one of the methods defined above to do the work. if (directory) Compress.zipDirectory(from, to); else Compress.gzipFile(from, to); } }
}
</source>
GZip with GZIPOutputStream
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.OutputStream; import java.util.zip.GZIPOutputStream; public class Main {
public static void main(String[] args) throws Exception { InputStream fin = new FileInputStream("a.dat"); OutputStream fout = new FileOutputStream("a.dat.gz"); GZIPOutputStream gzout = new GZIPOutputStream(fout); for (int c = fin.read(); c != -1; c = fin.read()) { gzout.write(c); } gzout.close(); }
}
</source>
Reads GZIP, Zip, and Jar files
<source lang="java">
/*
* Copyright (C) 2005 Caio Filipini, Sergio Umlauf * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Created on 14/09/2005 * */
import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.util.Enumeration; import java.util.Iterator; import java.util.jar.Attributes; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.zip.GZIPInputStream; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; /**
* Reads GZIP, Zip, and Jar files * * @author Sergio Umlauf * */
public class Zip {
/** * Reads a GZIP file and dumps the contents to the console. */ public static void readGZIPFile(String fileName) { // use BufferedReader to get one line at a time BufferedReader gzipReader = null; try { // simple loop to dump the contents to the console gzipReader = new BufferedReader( new InputStreamReader( new GZIPInputStream( new FileInputStream(fileName)))); while (gzipReader.ready()) { System.out.println(gzipReader.readLine()); } gzipReader.close(); } catch (FileNotFoundException fnfe) { System.out.println("The file was not found: " + fnfe.getMessage()); } catch (IOException ioe) { System.out.println("An IOException occurred: " + ioe.getMessage()); } finally { if (gzipReader != null) { try { gzipReader.close(); } catch (IOException ioe) {} } } } /** * Reads a Zip file, iterating through each entry and dumping the contents * to the console. */ public static void readZipFile(String fileName) { ZipFile zipFile = null; try { // ZipFile offers an Enumeration of all the files in the Zip file zipFile = new ZipFile(fileName); for (Enumeration e = zipFile.entries(); e.hasMoreElements();) { ZipEntry zipEntry = (ZipEntry) e.nextElement(); System.out.println(zipEntry.getName() + " contains:"); // use BufferedReader to get one line at a time BufferedReader zipReader = new BufferedReader( new InputStreamReader(zipFile.getInputStream(zipEntry))); while (zipReader.ready()) { System.out.println(zipReader.readLine()); } zipReader.close(); } } catch (IOException ioe) { System.out.println("An IOException occurred: " + ioe.getMessage()); } finally { if (zipFile != null) { try { zipFile.close(); } catch (IOException ioe) {} } } } /** * Reads a Jar file, displaying the attributes in its manifest and dumping * the contents of each file contained to the console. */ public static void readJarFile(String fileName) { JarFile jarFile = null; try { // JarFile extends ZipFile and adds manifest information jarFile = new JarFile(fileName); if (jarFile.getManifest() != null) { System.out.println("Manifest Main Attributes:"); Iterator iter = jarFile.getManifest().getMainAttributes().keySet().iterator(); while (iter.hasNext()) { Attributes.Name attribute = (Attributes.Name) iter.next(); System.out.println(attribute + " : " + jarFile.getManifest().getMainAttributes().getValue(attribute)); } System.out.println(); } // use the Enumeration to dump the contents of each file to the console System.out.println("Jar file entries:"); for (Enumeration e = jarFile.entries(); e.hasMoreElements();) { JarEntry jarEntry = (JarEntry) e.nextElement(); if (!jarEntry.isDirectory()) { System.out.println(jarEntry.getName() + " contains:"); BufferedReader jarReader = new BufferedReader( new InputStreamReader(jarFile.getInputStream(jarEntry))); while (jarReader.ready()) { System.out.println(jarReader.readLine()); } jarReader.close(); } } } catch (IOException ioe) { System.out.println("An IOException occurred: " + ioe.getMessage()); } finally { if (jarFile != null) { try { jarFile.close(); } catch (IOException ioe) {} } } }
}
</source>
Read some data from a gzip file
<source lang="java">
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */
import java.io.BufferedReader; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.util.zip.GZIPInputStream; /**
* Read some data from a gzip file. * * @author Ian F. Darwin, http://www.darwinsys.ru/ * @version $Id: ReadGZIP.java,v 1.4 2004/03/06 20:54:38 ian Exp $ */
public class ReadGZIP {
public static void main(String[] argv) throws IOException { String FILENAME = "file.txt.gz"; // Since there are 4 constructor calls here, I wrote them out in full. // In real life you would probably nest these constructor calls. FileInputStream fin = new FileInputStream(FILENAME); GZIPInputStream gzis = new GZIPInputStream(fin); InputStreamReader xover = new InputStreamReader(gzis); BufferedReader is = new BufferedReader(xover); String line; // Now read lines of text: the BufferedReader puts them in lines, // the InputStreamReader does Unicode conversion, and the // GZipInputStream "gunzip"s the data from the FileInputStream. while ((line = is.readLine()) != null) System.out.println("Read: " + line); }
}
</source>
Uncompress a file in the GZIP format
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.zip.GZIPInputStream; public class Main {
public static void main(String[] argv) throws Exception { String source = "s.gzip"; GZIPInputStream in = new GZIPInputStream(new FileInputStream(source)); String target = "outfile"; OutputStream out = new FileOutputStream(target); byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0) { out.write(buf, 0, len); } in.close(); out.close(); }
}
</source>
Uncompressing a File in the GZIP Format
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.zip.GZIPInputStream; public class Main {
public static void main(String[] argv) throws Exception { String inFilename = "infile.gzip"; GZIPInputStream in = new GZIPInputStream(new FileInputStream(inFilename)); String outFilename = "outfile"; OutputStream out = new FileOutputStream(outFilename); byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0) { out.write(buf, 0, len); } in.close(); out.close(); }
}
</source>
Ungzip with GZIPInputStream
<source lang="java">
import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.zip.GZIPInputStream; public class Main {
public static void main(String[] args) throws Exception { FileInputStream fin = new FileInputStream("a.gz"); GZIPInputStream gzin = new GZIPInputStream(fin); FileOutputStream fout = new FileOutputStream("a.dat"); for (int c = gzin.read(); c != -1; c = gzin.read()) { fout.write(c); } fout.close(); }
}
</source>