Eine einfache Zip -Komprimierung Dekompressionstool -Toolklasse, die mit der Java Basic -Klasse geschrieben wurde
Die Codekopie lautet wie folgt:
Paket sun.net.helper;
import Java.io.*;
import Java.util.logging.logger;
import Java.util.zip.*;
öffentliche Klasse Ziputil {
private endgültige statische Logger logger = logger.getLogger (ziputil.class.getName ());
private statische endgültige Int -Puffer = 1024*10;
/**
* Komprimieren Sie das angegebene Verzeichnis in eine ZIP -Datei mit demselben Namen wie im Verzeichnis und passen Sie den Komprimierungspfad an
* @param SourceFilePath Zieldateiweg
* @param zipfilepath Geben Sie den Zip -Dateipfad an
* @zurückkehren
*/
public static boolean Zip (String SourceFilepath, String Zipfilepath) {
boolescher Ergebnis = falsch;
Datei Source = New Datei (SourceFilePath);
if (! source.exists ()) {
logger.info (SourceFilePath+"existiert nicht.");
Rückgabeergebnis;
}
if (! source.isdirectory ()) {
logger.info (SourceFilePath+"ist kein Verzeichnis.");
Rückgabeergebnis;
}
Datei zipfile = neue Datei (ZiPFilepath+"/"+source.getName ()+". Zip");
if (zipfile.exists ()) {
logger.info (zipfile.getName ()+"ist bereits existiert.");
Rückgabeergebnis;
}anders{
if (! zipfile.getParentFile (). exists ()) {
if (! zipfile.getParentFile (). mkdirs ()) {
logger.info ("Kann keine Datei erstellen"+zipfile.getName ());
Rückgabeergebnis;
}
}
}
logger.info ("ZIP -Datei erstellen ...");
FileOutputStream dest = null;
ZipoutputStream out = null;
versuchen {
dest = new FileOutputStream (Zipfile);
CheckedOutputStream checksum = new checkedOutputStream (dest, neuer adler32 ());
out = neu zipoutputStream (neuer bufferedOutputStream (Prüfsumme));
out.setMethod (ZipoutputStream.Deflated);
compress (Quelle, out, source.getName ());
Ergebnis = wahr;
} catch (FilenotFoundException e) {
E. printstacktrace ();
} Endlich {
if (out! = null) {
versuchen {
out.closeEntry ();
} catch (ioException e) {
E. printstacktrace ();
}
versuchen {
out.close ();
} catch (ioException e) {
E. printstacktrace ();
}
}
}
if (Ergebnis) {
logger.info ("fertig.");
}anders{
logger.info ("fail.");
}
Rückgabeergebnis;
}
private statische Hohlraumkompress (Dateidatei, ZipoutputStream Out, String MainFileName) {
if (file.isfile ()) {
FileInputStream fi = null;
BufferedInputStream Origin = null;
versuchen {
fi = new FileInputStream (Datei);
Origin = New BufferedInputStream (FI, Buffer);
int index = file.getabsolutepath (). IndexOf (MainFileName);
String -EintragName = Datei.getabsolUTepath (). Substring (Index);
System.out.println (Eintragsname);
ZIPEntry -Eintrag = neu Zipentry (Eintragsname);
out.putNextEntry (Eintrag);
byte [] data = new byte [puffer];
int Count;
while ((count = Origin.read (Daten, 0, Puffer))! = -1) {
out.write (Daten, 0, count);
}
} catch (FilenotFoundException e) {
E. printstacktrace ();
} catch (ioException e) {
E. printstacktrace ();
} Endlich {
if (Origin! = null) {
versuchen {
Origin.close ();
} catch (ioException e) {
E. printstacktrace ();
}
}
}
} else if (file.isdirectory ()) {
Datei [] fs = file.listfiles ();
if (fs! = null && fs.length> 0) {
für (Datei f: fs) {
Kompress (f, out, mainFileName);
}
}
}
}
/**
* Entpacken Sie die ZIP -Datei in das angegebene Verzeichnis.
* @param zipfile
* @param destpath
* @zurückkehren
*/
public static boolean Unzip (Datei Zipfile, String destpath) {
boolescher Ergebnis = falsch;
if (! zipfile.exists ()) {
logger.info (zipfile.getName ()+"existiert nicht.");
Rückgabeergebnis;
}
Datei target = new Datei (destpath);
if (! target.exists ()) {
if (! target.mkdirs ()) {
logger.info ("Kann keine Datei erstellen"+target.getName ());
Rückgabeergebnis;
}
}
String mainFileName = ZipFile.getName (). Ersetzen (". Zip", "");
Datei targetFile = neue Datei (destpath+"/"+mainFileName);
if (targetFile.exists ()) {
logger.info (targetFile.getName ()+"bereits existieren");
Rückgabeergebnis;
}
ZipinputStream zis = null;
logger.info ("Unzip -Datei starten ...");
versuchen {
FileInputStream fis = new FileInputStream (Zipfile);
CheckedInputStream Checksum = New CheckedInputStream (FIS, New Adler32 ());
Zis = neu ZipinputStream (neuer BufferedInputStream (Prüfsumme));
Zipentry -Eintrag;
while ((Eintrag = zis.getNextEntry ())! = null) {
int Count;
Byte -Daten [] = neues Byte [Puffer];
String -EintragName = Eintrag.getName ();
int index = Eintragsname.indexof (MainFileName);
String newEnryname = destpath+"/"+Eintragsname.substring (Index);
System.out.println (NewEntryname);
Datei temp = neue Datei (NewEnryname) .GetParentFile ();
if (! temp.exists ()) {
if (! temp.mkdirs ()) {
Neue RunTimeException werfen ("Datei erstellen" +temp.getName () +"fail");
}
}
FileOutputStream fos = new FileOutputStream (NewEnryname);
PufufferedOutputStream dest = neuer bufferedOutputStream (FOS, Buffer);
while ((count = zis.read (Daten, 0, Puffer))! = -1) {
dest.write (Daten, 0, count);
}
Dest.Flush ();
dest.close ();
}
Ergebnis = wahr;
} catch (FilenotFoundException e) {
E. printstacktrace ();
} catch (ioException e) {
E. printstacktrace ();
} Endlich {
if (zis! = null) {
versuchen {
Zis.close ();
} catch (ioException e) {
E. printstacktrace ();
}
}
}
if (Ergebnis) {
logger.info ("fertig.");
}anders{
logger.info ("fail.");
}
Rückgabeergebnis;
}
public static void main (String [] args) löst ioException {aus
//Ziputil.zip("d:/apache-tomcat-7.0.30 "," d:/temp ");
Datei zipfile = neue Datei ("d: /temp/apache-tomcat-7.0.30.zip");
Ziputil.unzip (Zipfile, "D:/temp");
}
}
Ein weiteres Beispiel für Komprimierungs- und Dekompressionsbeispiele. Weitere Informationen finden Sie in den beiden Tools.
Die Codekopie lautet wie folgt:
Paket com.lanp;
Import Java.io.file;
import Java.io.FileInputStream;
importieren java.io.fileoutputStream;
importieren java.io.ioException;
import Java.util.zip.zipentry;
import Java.util.zip.zipexception;
Import Java.util.zip.zipfile;
import Java.util.zip.zipinputStream;
/**
* Entpacken Sie die Datei mit ZIP -komprimierter Datei in das angegebene Verzeichnis
*/
öffentliche endgültige Klasse Ziptofile {
/**
* Die Cache -Größe standardmäßig 20480
*/
private endgültige statische int file_buffer_size = 20480;
private ziptofile () {
}
/**
* Entpacken Sie die mit ZIP -komprimierte Datei des angegebenen Verzeichnisses in das angegebene Verzeichnis
* @param zipfilepathzip komprimierter Dateipfad
* @param zipfilenamezip komprimierter Dateiname
* @param targetFiledirzip komprimierte Datei, die zu extrahieren sind
* @Return Flag Boolean Rückgabewert
*/
public static boolean unzip (String zipfilepath, String zipfilename, String targetFiledir) {
boolesche Flagge = Falsch;
// 1.
Datei Datei = null; // komprimierte Datei (mit Pfad)
Zipfile zipfile = null;
Datei = neue Datei (ZipFilepath + "/" + Zipfilename);
System.out.println (">>>>>>> die Datei [" + zipfilepath + "/" + zipfilename + "] zum [" + targetFiledir + "] verzeichnis <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<eid.“);
if (false == File.exists ()) {
System.out.println (">>>>>> komprimierte Datei [" + zipfilepath + "/" + zipfileName + "] existiert nicht <<<<<<<?");
false zurückgeben;
} else if (0 == Datei.length ()) {
System.out.println (">>>>>> komprimierte Datei [" + Zipfilepath + "/" + Zipfilename + "] Die Größe ist 0 und erfordert keine Dekompression <<<<<<");
false zurückgeben;
} anders {
// 2.
byte [] buf = new byte [file_buffer_size];
int readSize = -1;
ZipinputStream zis = null;
FileOutputStream fos = null;
versuchen {
// Überprüfen Sie, ob es sich um eine ZIP -Datei handelt
zipfile = neu zipfile (Datei);
zipfile.close ();
// Bestimmen Sie, ob das Zielverzeichnis existiert.
Datei newdir = new Datei (targetFiledir);
if (false == newdir.exists ()) {
newdir.mkdirs ();
newdir = null;
}
ZIS = New ZipinputStream (neuer FileInputStream (Datei));
Zipentry zipentry = zis.getNextEntry ();
// Die Verarbeitung von Dateien im komprimierten Paket starten
while (null! = zipentry) {
String zipEnterryName = zipEntry.getName (). Ersetzen ('//', '/');
// Beurteilen Sie, ob Zipentry ein Verzeichnis ist
if (zipentry.isdirectory ()) {
int indexNumber = zipEnterryName.lastIndexof ('/');
Dateieintragsdirs = Neue Datei (TargetFiledir + "/" + zipentryname.substring (0, IndexNumber));
Eintragdirs.mkdirs ();
Eintragsdirs = NULL;
} anders {
versuchen {
fos = new FileOutputStream (TargetFiledir + "/" + ZipEnterryname);
while ((readSize = zis.read (buf, 0, File_buffer_size)! = -1) {
fos.write (buf, 0, readsize);
}
} catch (Ausnahme e) {
E. printstacktrace ();
Neue RunTimeException werfen (e.getCause ());
} Endlich {
versuchen {
if (null! = fos) {
fos.close ();
}
} catch (ioException e) {
E. printstacktrace ();
Neue RunTimeException werfen (e.getCause ());
}
}
}
ZipEntry = Zis.getNextentry ();
}
Flag = wahr;
} catch (ZipException e) {
E. printstacktrace ();
Neue RunTimeException werfen (e.getCause ());
} catch (ioException e) {
E. printstacktrace ();
Neue RunTimeException werfen (e.getCause ());
} Endlich {
versuchen {
if (null! = zis) {
Zis.close ();
}
if (null! = fos) {
fos.close ();
}
} catch (ioException e) {
E. printstacktrace ();
Neue RunTimeException werfen (e.getCause ());
}
}
}
Rückflagge;
}
/**
* Hauptmethode zum Testen
*/
public static void main (String [] args) {
String zipfilepath = "c: // home";
String zipfilename = "lp20120301.zip";
String targetFiledir = "C: // home // lp20120301";
boolesche Flagge = ZiptoFile.unzip (Zipfilepath, Zipfilename, TargetFiledir);
if (Flag) {
System.out.println (">>>>>> entschlüsseln erfolgreich <<<<<<<");
} anders {
System.out.println (">>>>>>> Dekompression fehlgeschlagen <<<<<<");
}
}
}