Make a ZIP archive flat

Your zip archive may have other zip archives inside it. One may want to extract the nested zip archive’s contents into the parent archive to get a flat structure.

Current archive structure

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

Desired archive structure

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

If you are not familiar with Aspose.Zip read how to extract zip archive first.

Overal explanation

First, we need to list all the entries of the archive. Regular entries should be kept as they are, we should not even decompress them. Entries that are archives themselves need to be extracted to memory and removed from the outer archive. Their content needs to be included in the main archive.

Detecting entries that are archives

Lets decide which entries are archives itself. We can figure this out by extension of entry name. Later we will remove those entries from main archive, so keep such entries in a list.

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

Extracting entry’s content to memory

Aspose.Zip allows extracting the content of zip entry into any writable stream, not only to a file. So, we can extract a nested archive to a memory stream.

Please note: the virtual memory must be big enough to keep all extracted content.

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

After that innerCompressed stream contains the inner archive itself. The Archive constructor allows decompressing the stream provided. So, we can extract it as well:

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

Excluding entries

We can remove an entry from zip archive with particular method.

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

Put it all together

Here is the complete algorithm.

try(Archive outer = new Archive("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()) {
        // Find an entry which is an archive itself
        if(entry.getName().toLowerCase(Locale.ROOT).endsWith(".zip")) {
            // Keep reference to the entry in order to remove it from the archive later
            entriesToDelete.add(entry);

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