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