Cómo crear un archivo ZIP plano

Su archivo zip puede tener otros archivos zip en su interior. Es posible que desee extraer el contenido del archivo zip anidado en el archivo principal para obtener una estructura plana.

Estructura actual del archivo

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

Estructura de archivo deseada

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

Si no está familiarizado con Aspose.Zip lea primero cómo extraer archivo zip.

**Explicación general

Primero, necesitamos listar todas las entradas del archivo. Las entradas normales deben mantenerse tal cual, ni siquiera debemos descomprimirlas. Las entradas que son archivos en sí mismas deben ser extraídas a la memoria y eliminadas del archivo externo. Su contenido debe ser incluido en el archivo principal.

Detección de entradas que son archivos

Decidamos qué entradas son archivos. Podemos averiguarlo por la extensión del nombre de la entrada. Más tarde vamos a eliminar las entradas del archivo principal, por lo que mantener este tipo de entradas en una lista.

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

Extrayendo el contenido de la entrada a la memoria

Aspose.Zip permite extraer el contenido de una entrada zip a cualquier flujo escribible, no sólo a un archivo. Así, podemos extraer un archivo anidado a un flujo de memoria.

Nota: la memoria virtual debe ser lo suficientemente grande como para guardar todo el contenido extraído.

byte[] b = nuevo 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);
}

Después de eso innerCompressed stream contiene el propio archivo interno. El Constructor de archivo permite descomprimir el flujo proporcionado. Por lo tanto, también podemos extraerlo:

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

Excluyendo entradas

Podemos eliminar una entrada del archivo zip con método particular.

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

Ponerlo todo junto

Aquí está el algoritmo completo.

try(Archivo externo = nuevo Archivo("externo.zip")) {
    ArrayList<ArchiveEntry> entriesToDelete = new ArrayList<ArchiveEntry>();
    ArrayList<String> namesToInsert = new ArrayList<String>();
    ArrayList<InputStream> contentToInsert = new ArrayList<InputStream>();
    for(ArchiveEntry entry : outer.getEntries()) {
        // Buscar una entrada que sea un archivo propiamente dicho
        if(entry.getName().toLowerCase(Locale.ROOT).endsWith(".zip")) {
            // Guarda la referencia a la entrada para poder eliminarla del archivo más adelante
            entriesToDelete.add(entrada);

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