So erstellen Sie ein flaches ZIP-Archiv

Ihr Zip-Archiv kann andere Zip-Archive enthalten. Vielleicht möchten Sie den Inhalt des verschachtelten Zip-Archivs in das übergeordnete Archiv extrahieren, um eine flache Struktur zu erhalten.

Aktuelle Archivstruktur

outer.zip
 ├first.txt
 ├inner.zip
 │ ├game.exe
 │ └subitem.bin
 └picture.gif

Gewünschte Archivstruktur

flatten.zip
 ├first.txt
 ├picture.gif
 ├game.exe
 └subitem.bin

Wenn Sie mit Aspose.Zip nicht vertraut sind, lesen Sie zuerst, wie man Zip-Archiv extrahiert.

Einfache Erklärung

Zuerst müssen wir alle Einträge des Archivs auflisten. Reguläre Einträge sollten so belassen werden, wie sie sind, wir sollten sie nicht einmal dekomprimieren. Einträge, die selbst Archive sind, müssen in den Speicher extrahiert und aus dem äußeren Archiv entfernt werden. Ihr Inhalt muss in das Hauptarchiv aufgenommen werden.

Erkennen von Einträgen, die Archive sind

Lassen Sie uns entscheiden, welche Einträge selbst Archive sind. Wir können dies anhand der Erweiterung des Eintragsnamens herausfinden. Später werden wir diese Einträge aus dem Hauptarchiv entfernen, also behalten wir solche Einträge in einer Liste.

if(eintrag.getName().toLowerCase(Locale.ROOT).endsWith(".zip")) {
    entriesToDelete.add(Eintrag);
    ...
}

Inhalt des Eintrags in den Speicher extrahieren

Aspose.Zip ermöglicht das Extrahieren des Inhalts eines Zip-Eintrags in einen beliebigen beschreibbaren Stream, nicht nur in eine Datei. Wir können also ein verschachteltes Archiv in einen Speicherstrom extrahieren.

Bitte beachten Sie: Der virtuelle Speicher muss groß genug sein, um alle extrahierten Inhalte zu speichern.

byte[] b = new byte[8192];
int bytesLesen;
InputStream entryStream = entry.open();
ByteArrayOutputStream innerCompressed = new ByteArrayOutputStream();
while (0 < (bytesRead = entryStream.read(b, 0, b.length))) {
    innerCompressed.write(b, 0, bytesRead);
}

Danach enthält innerCompressed stream das innere Archiv selbst. Der Archive constructor ermöglicht die Dekomprimierung des bereitgestellten Streams. Wir können ihn also auch extrahieren:

Archive inner = new Archive(new ByteArrayInputStream(innerCompressed.toByteArray()));

Einträge ausschließen

Mit bestimmte Methode können wir einen Eintrag aus dem Zip-Archiv entfernen.

for(ArchiveEntry e : entriesToDelete) {
    outer.deleteEntry(e);
}

Alles zusammenfügen

Hier ist der vollständige Algorithmus.

try(Archiv outer = new Archiv("outer.zip")) {
    ArrayList<ArchiveEntry> entriesToDelete = new ArrayList<ArchiveEntry>();
    ArrayList<String> namesToInsert = new ArrayList<String>();
    ArrayList<InputStream> contentToInsert = new ArrayList<InputStream>();
    for(ArchiveEntry entry : outer.getEntries()) {
        // Einen Eintrag finden, der selbst ein Archiv ist
        if(entry.getName().toLowerCase(Locale.ROOT).endsWith(".zip")) {
            // Behalte den Verweis auf den Eintrag, um ihn später aus dem Archiv entfernen zu können
            entriesToDelete.add(Eintrag);

            //This extracts the entry to a memory stream
            byte[] b = new byte[8192];
            int bytesRead;
            InputStream entryStream = entry.open();
            ByteArrayOutputStream innerCompressed = new ByteArrayOutputStream();
            while (0 < (bytesRead = entryStream.read(b, 0, b.length))) {
                innerCompressed.write(b, 0, bytesRead);
            }

            // We know that content of the entry is a zip archive, so we may extract
            try(Archive inner = new Archive(new ByteArrayInputStream(innerCompressed.toByteArray()))) {

                // Loop over entries of inner archive
                for(ArchiveEntry ie : inner.getEntries()) {

                    // Keep the name of inner entry.
                    namesToInsert.add(ie.getName());

                    InputStream ieStream = ie.open();
                    ByteArrayOutputStream content = new ByteArrayOutputStream();
                    while (0 < (bytesRead = ieStream.read(b, 0, b.length))) {
                        content.write(b, 0, bytesRead);
                    }

                    // Keep the content of inner entry.
                    contentToInsert.add(new ByteArrayInputStream(content.toByteArray()));
                }
            }
        }
    }

    for(ArchiveEntry e : entriesToDelete) {
        // Delete all the entries which are archives itself
        outer.deleteEntry(e);
    }

    for(int i = 0; i < namesToInsert.size(); i++) {
        // Adds entries which were entries of inner archives
        outer.createEntry(namesToInsert.get(i), contentToInsert.get(i));
    }

    outer.save("flatten.zip");
} catch (Exception ex) {
    System.out.println(ex);
}