Ich habe mir die Standard-Zip-Bibliothek angesehen, die mit dem JDK und den Apache-Komprimierungsbibliotheken geliefert wird, und bin aus drei Gründen mit ihnen unzufrieden:

1. Sie sind aufgebläht und haben ein schlechtes API-Design. Ich muss 50 Zeilen Boiler-Plate-Byte-Array-Ausgabe, Zip-Eingabe, Datei-Out-Streams und Schließen relevanter Streams schreiben und Ausnahmen abfangen und Byte-Puffer selbst verschieben . Warum kann ich keine einfache API haben, die so aussieht Zipper.unzip(InputStream zipFile, File targetDirectory, String password = null)und Zipper.zip(File targetDirectory, String password = null)einfach funktioniert?

2. Es scheint, dass das Entpacken beim Entpacken die Metadaten der Datei zerstört und die Kennwortbehandlung fehlerhaft ist.

3. Außerdem waren alle Bibliotheken, die ich ausprobiert habe, 2-3x langsam im Vergleich zu den Befehlszeilen-Zip-Tools, die ich mit UNIX erhalte.

Für mich sind (2) und (3) kleine Punkte, aber ich möchte wirklich eine gut getestete Bibliothek mit einer einzeiligen Schnittstelle.

Ich weiß, dass es spät ist und es gibt viele Antworten, aber dieses zip4j ist eine der besten Bibliotheken zum Zippen, die ich verwendet habe. Es ist einfach (kein Boiler-Code) und kann problemlos passwortgeschützte Dateien verarbeiten.

import net.lingala.zip4j.exception.ZipException;
import net.lingala.zip4j.core.ZipFile;


public static void unzip(){
    String source = "some/compressed/file.zip";
    String destination = "some/destination/folder";
    String password = "password";

    try {
         ZipFile zipFile = new ZipFile(source);
         if (zipFile.isEncrypted()) {
            zipFile.setPassword(password);
         }
         zipFile.extractAll(destination);
    } catch (ZipException e) {
        e.printStackTrace();
    }
}

Die Maven-Abhängigkeit ist:

<dependency>
    <groupId>net.lingala.zip4j</groupId>
    <artifactId>zip4j</artifactId>
    <version>1.3.2</version>
</dependency>

Mit Apache Commons-IO ‚s IOUtilskönnen Sie dies tun:

try (java.util.zip.ZipFile zipFile = new ZipFile(file)) {
  Enumeration<? extends ZipEntry> entries = zipFile.entries();
  while (entries.hasMoreElements()) {
    ZipEntry entry = entries.nextElement();
    File entryDestination = new File(outputDir,  entry.getName());
    if (entry.isDirectory()) {
        entryDestination.mkdirs();
    } else {
        entryDestination.getParentFile().mkdirs();
        try (InputStream in = zipFile.getInputStream(entry);
             OutputStream out = new FileOutputStream(entryDestination)) {
            IOUtils.copy(in, out);
        }
    }
  }
}

Es ist immer noch ein Boilerplate-Code, aber es gibt nur eine nicht exotische Abhängigkeit: Commons-IO

Extrahieren Sie die Zip-Datei und alle ihre Unterordner nur mit dem JDK:

private void extractFolder(String zipFile,String extractFolder) 
{
    try
    {
        int BUFFER = 2048;
        File file = new File(zipFile);

        ZipFile zip = new ZipFile(file);
        String newPath = extractFolder;

        new File(newPath).mkdir();
        Enumeration zipFileEntries = zip.entries();

        // Process each entry
        while (zipFileEntries.hasMoreElements())
        {
            // grab a zip file entry
            ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
            String currentEntry = entry.getName();

            File destFile = new File(newPath, currentEntry);
            //destFile = new File(newPath, destFile.getName());
            File destinationParent = destFile.getParentFile();

            // create the parent directory structure if needed
            destinationParent.mkdirs();

            if (!entry.isDirectory())
            {
                BufferedInputStream is = new BufferedInputStream(zip
                .getInputStream(entry));
                int currentByte;
                // establish buffer for writing file
                byte data[] = new byte[BUFFER];

                // write the current file to disk
                FileOutputStream fos = new FileOutputStream(destFile);
                BufferedOutputStream dest = new BufferedOutputStream(fos,
                BUFFER);

                // read and write until last byte is encountered
                while ((currentByte = is.read(data, 0, BUFFER)) != -1) {
                    dest.write(data, 0, currentByte);
                }
                dest.flush();
                dest.close();
                is.close();
            }


        }
    }
    catch (Exception e) 
    {
        Log("ERROR: "+e.getMessage());
    }

}

Zip-Dateien und alle ihre Unterordner:

 private void addFolderToZip(File folder, ZipOutputStream zip, String baseName) throws IOException {
    File[] files = folder.listFiles();
    for (File file : files) {
        if (file.isDirectory()) {
            addFolderToZip(file, zip, baseName);
        } else {
            String name = file.getAbsolutePath().substring(baseName.length());
            ZipEntry zipEntry = new ZipEntry(name);
            zip.putNextEntry(zipEntry);
            IOUtils.copy(new FileInputStream(file), zip);
            zip.closeEntry();
        }
    }
}

Eine weitere Option, die Sie auschecken können, ist zt-zip, das auf der Maven-Zentral- und Projektseite unter https://github.com/zeroturnaround/zt-zip verfügbar ist

Es verfügt über die Standardfunktion zum Packen und Entpacken (in Streams und im Dateisystem) + viele Hilfsmethoden zum Testen von Dateien in einem Archiv oder zum Hinzufügen / Entfernen von Einträgen.

Vollständige Implementierung zum Zip / Entpacken eines Ordners / einer Datei mit zip4j

Laden Sie das Glas von hier herunter und fügen Sie es Ihrem Projekterstellungspfad hinzu. Der classBalg kann jede Datei oder jeden Ordner mit oder ohne Passwortschutz komprimieren und extrahieren.

import java.io.File;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.util.Zip4jConstants;
import net.lingala.zip4j.core.ZipFile;  

public class Compressor {
    public static void zip(String targetPath, String destinationFilePath, String password) {
        try {
            ZipParameters parameters = new ZipParameters();
            parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
            parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);

            if(password.length()>0){
                parameters.setEncryptFiles(true);
                parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_AES);
                parameters.setAesKeyStrength(Zip4jConstants.AES_STRENGTH_256);
                parameters.setPassword(password);
            }

            ZipFile zipFile = new ZipFile(destinationFilePath);

            File targetFile = new File(targetPath);
            if(targetFile.isFile()){
                zipFile.addFile(targetFile, parameters);
            }else if(targetFile.isDirectory()){
                zipFile.addFolder(targetFile, parameters);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void unzip(String targetZipFilePath, String destinationFolderPath, String password) {
        try {
            ZipFile zipFile = new ZipFile(targetZipFilePath);
            if (zipFile.isEncrypted()) {
                zipFile.setPassword(password);
            }
            zipFile.extractAll(destinationFolderPath);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**/ /// for test only
    public static void main(String[] args) {

        String targetPath = "target\\file\\or\\folder\\path";
        String zipFilePath = "zip\\file\\Path"; 
        String unzippedFolderPath = "destination\\folder\\path";
        String password = "your_password"; // keep it EMPTY<""> for applying no password protection

        Compressor.zip(targetPath, zipFilePath, password);
        Compressor.unzip(zipFilePath, unzippedFolderPath, password);
    }/**/
}

Ein sehr schönes Projekt ist TrueZip .

TrueZIP ist ein Java-basiertes Plug-In-Framework für virtuelle Dateisysteme (VFS), das transparenten Zugriff auf Archivdateien bietet, als wären sie nur einfache Verzeichnisse

Zum Beispiel (von der Website ):

File file = new TFile("archive.tar.gz/README.TXT");
OutputStream out = new TFileOutputStream(file);
try {
   // Write archive entry contents here.
   ...
} finally {
   out.close();
}

Eine weitere Option ist JZlib . Nach meiner Erfahrung ist es weniger "dateizentriert" als zip4J. Wenn Sie also an In-Memory-Blobs anstatt an Dateien arbeiten müssen, sollten Sie es sich ansehen.

Hier finden Sie ein vollständiges Beispiel für das rekursive Komprimieren und Entpacken von Dateien: http://developer-tips.hubpages.com/hub/Zipping-and-Unzipping-Nested-Directories-in-Java-using-Apache-Commons-Compress

Haben Sie sich http://commons.apache.org/vfs/ angesehen ? Es behauptet, viele Dinge für Sie zu vereinfachen. Aber ich habe es nie in einem Projekt verwendet.

Mir sind auch keine anderen Java-Native-Komprimierungsbibliotheken als das JDK oder die Apache-Komprimierung bekannt.

Ich erinnere mich, dass wir einige Funktionen aus Apache Ant herausgerissen haben - sie haben viele Utils für die Komprimierung / Dekomprimierung eingebaut.

Beispielcode mit VFS würde folgendermaßen aussehen:

File zipFile = ...;
File outputDir = ...;
FileSystemManager fsm = VFS.getManager();
URI zip = zipFile.toURI();
FileObject packFileObject = fsm.resolveFile(packLocation.toString());
FileObject to = fsm.toFileObject(destDir);
FileObject zipFS;
try {
    zipFS = fsm.createFileSystem(packFileObject);
    fsm.toFileObject(outputDir).copyFrom(zipFS, new AllFileSelector());
} finally {
    zipFS.close();
}