Comment créer une archive ZIP plate

Votre archive zip peut contenir d’autres archives zip. On peut vouloir extraire le contenu de l’archive zip imbriquée dans l’archive mère pour obtenir une structure plate.

Structure actuelle de l'archive

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

Structure des archives souhaitée

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

Si vous n’êtes pas familier avec Aspose.Zip, lisez d’abord comment extraire une archive zip.

Explication générale

Tout d’abord, nous devons lister toutes les entrées de l’archive. Les entrées régulières doivent être conservées telles quelles, nous ne devons même pas les décompresser. Les entrées qui sont elles-mêmes des archives doivent être extraites de la mémoire et supprimées de l’archive externe. Leur contenu doit être inclus dans l’archive principale.

Détection des entrées qui sont des archives

Déterminons quelles entrées sont des archives. Nous pouvons le découvrir par l’extension du nom de l’entrée. Plus tard, nous supprimerons ces entrées de l’archive principale, donc gardons ces entrées dans une liste.

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

Extraction du contenu de l’entrée dans la mémoire

Aspose.Zip permet d’extraire le contenu d’une entrée zip dans n’importe quel flux accessible en écriture, et pas seulement dans un fichier. Ainsi, nous pouvons extraire une archive imbriquée dans un flux mémoire.

Remarque : la mémoire virtuelle doit être suffisamment grande pour contenir tout le contenu extrait.

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

Ensuite, le flux innerCompressed contient l’archive interne elle-même. Le Constructeur d’archive permet de décompresser le flux fourni. Nous pouvons donc également l’extraire :

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

Exclusion des entrées

Nous pouvons supprimer une entrée de l’archive zip avec méthode particulière.

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

Mettre le tout ensemble

Voici l’algorithme complet.

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()) {
        // Recherche d'une entrée qui est elle-même une archive
        if(entry.getName().toLowerCase(Locale.ROOT).endsWith(".zip")) {
            // Conserver la référence à l'entrée afin de la supprimer de l'archive ultérieurement
            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) ;
}