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);
}