Java/File Input Output/GZIP

Материал из Java эксперт
Перейти к: навигация, поиск

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>