Comment zipper et dézipper des fichiers en Java

Vue d’ensemble

Cet article vous apprendra à compresser par programme des fichiers Zip à l’aide de diverses méthodes utilisant l’API Java et des exemples de code. Vous apprendrez à zipper ou à compresser un ou plusieurs fichiers, ainsi qu’à zipper des fichiers simultanément. Vous apprendrez également à décompresser ou dézipper des fichiers.

Zipper ou compresser des fichiers en Java et décompresser ou dézipper des fichiers en Java

L’API Aspose.ZIP vous permet de compresser et de décompresser des fichiers sans vous soucier de la structure du fichier sous-jacent. Cet article montre comment travailler avec la compression d’un seul ou de plusieurs fichiers.

Compression de fichiers

Compression d’un seul fichier

Étapes:Compression d’un fichier unique en Java

1. Créez un file output stream avec le nom souhaité de votre fichier zip de sortie.
2. Créez un flux d’entrée de fichier du fichier de données à compresser.
3. Créez une instance de la classe Archive et transmettez-lui une instance de la classe ArchiveEntrySettings.
4. Ajoutez le fichier de données créé à l’étape 2 à l’aide de la méthode Archive.createEntry.
5. Zipper le fichier de données à l’aide de la méthode Archive.save et lui transmettre le flux de fichiers créé à l’étape 1.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "CompressSingleFile_out.zip")) {
    /Fichier à ajouter à l'archive
    try (FileInputStream source1 = new FileInputStream(dataDir + "alice29.txt")) {
        try (Archive archive = new Archive(new ArchiveEntrySettings())) {
            archive.createEntry("alice29.txt", source1) ;
            archive.save(zipFile) ;
        }
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}

Compression de plusieurs fichiers

Étapes:Compression de plusieurs fichiers en Java

1. Créez un flux de fichiers avec le nom souhaité de votre fichier zip de sortie.
2. Créez un flux de fichiers pour le premier fichier de données à compresser.
3. Créez un flux de fichiers pour le deuxième fichier de données à compresser.
4. Créez une instance de la classe Archive.
5. Ajoutez les fichiers de données créés aux étapes 2 et 3 à l’aide de la méthode Archive.createEntry.
6. Créez une instance de la classe ArchiveSaveOptions.
7. Zipper les fichiers de données à l’aide de la méthode Archive.save et lui transmettre le flux de fichiers créé à l’étape 1 et l’instance de ArchiveSaveOptions créée à l’étape précédente.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "CompressSingleFile_out.zip")) {
    try (FileInputStream source1 = new FileInputStream(dataDir + "alice29.txt")) {
        try (FileInputStream source2 = new FileInputStream(dataDir + "asyoulik.txt")) {
            try (Archive archive = new Archive(new ArchiveEntrySettings())) {
                archive.createEntry("alice29.txt", source1) ;
                archive.createEntry("asyoulik.txt", source2) ;
                ArchiveSaveOptions options = new ArchiveSaveOptions() ;
                options.setEncoding(StandardCharsets.US_ASCII) ;
                options.setArchiveComment("Il y a deux poèmes du corpus Canterbury") ;
                archive.save(zipFile, options) ;
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}

Compression des fichiers par Info Fichier

Étapes:Compresser des fichiers par information de fichier en Java

1. Ouvrez un flux de sortie de fichier avec le nom souhaité de votre fichier zip de sortie.
2. Créez l’objet File de votre premier fichier de données à compresser.
3. Créez l’objet File de votre deuxième fichier de données à compresser.
4. Créez une instance de la classe Archive.
5. Ajoutez les fichiers de données créés aux étapes 2 et 3 à l’aide de la méthode Archive.createEntry.
6. Créez une instance de la classe ArchiveSaveOptions.
7. Zipper les fichiers de données à l’aide de la méthode Archive.save et lui transmettre le flux de fichiers créé à l’étape 1 et l’instance de ArchiveSaveOptions créée à l’étape précédente.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "CompressFilesByFileInfo_out.zip")) {
    Fichier fi1 = nouveau Fichier(dataDir + "alice29.txt") ;
    Fichier fi2 = nouveau fichier (dataDir + "fields.c") ;
    try (Archive archive = new Archive()) {
        archive.createEntry("alice29.txt", fi1) ;
        archive.createEntry("fields.c", fi2) ;
        ArchiveSaveOptions options = new ArchiveSaveOptions() ;
        options.setEncoding(StandardCharsets.US_ASCII) ;
        archive.save(zipFile, options) ;
    }
} catch (IOException ignored) {
    System.out.println(ex) ;
}

Stockage de fichiers dans des archives sans compression

Etapes:Stockage de fichiers dans des archives sans compression en utilisant Java

1. Ouvrez un flux de sortie de fichier avec le nom souhaité de votre fichier zip de sortie.
2. Créez des objets File pour vos fichiers de données à stocker dans l’archive.
3. Créez une instance de la classe ArchiveEntrySettings et transmettez-lui une instance de la classe StoreCompressionSettings.
4. Créez une instance de la classe Archive et transmettez-lui une instance de la classe ArchiveEntrySettings créée à l’étape précédente.
5. Ajouter les objets Fichier créés à l’étape 2 en utilisant la méthode Archive.createEntry.
6. Créez une instance de ArchiveSaveOptions et définissez l’encodage à StandardCharsets.US_ASCII en utilisant la méthode ArchiveSaveOptions.setEncoding.
7. Zippez les fichiers de données à l’aide de la méthode Archive.save et passez-lui le flux de fichiers créé à l’étape 1 et l’instance de ArchiveSaveOptions créée à l’étape précédente.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "StoreMultipleFilesWithoutCompression_out.zip")) {
    Fichier fi1 = nouveau Fichier(dataDir + "alice29.txt") ;
    Fichier fi2 = nouveau fichier (dataDir + "fields.c") ;
    try (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings()))) {
        archive.createEntry("alice29.txt", fi1) ;
        archive.createEntry("fields.c", fi2) ;
        ArchiveSaveOptions options = new ArchiveSaveOptions() ;
        options.setEncoding(StandardCharsets.US_ASCII) ;
        archive.save(zipFile, options) ;
    }
} catch (IOException ignored) {
    System.out.println(ex) ;
}

Utilisation du parallélisme pour compresser les fichiers

Steps:Utiliser le parallélisme pour compresser des fichiers en utilisant Java

1. Ouvrez un flux de sortie de fichier avec le nom souhaité de votre fichier zip de sortie.
2. Ouvrez des flux d’entrée de fichiers pour vos premier et deuxième fichiers de données à compresser.
3. Créez une instance de la classe Archive.
4. Ajoutez les fichiers de données créés à l’étape 2 à l’aide de la méthode Archive.createEntry.
5. Créer une instance de la classe ParallelOptions et définir ParallelCompressionMode.Always en utilisant la méthode ParallelOptions.setParallelCompressInMemory.
6. Créer une instance de ArchiveSaveOptions et définir les options parallèles avec l’instance ci-dessus en utilisant la méthode ArchiveSaveOptions.setParallelOptions.
7. Zippez les fichiers de données à l’aide de la méthode Archive.save et passez-lui le flux de fichiers créé à l’étape 1 et l’instance de ArchiveSaveOptions créée à l’étape précédente.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "UsingParallelismToCompressFiles_out.zip")) {
    try (FileInputStream source1 = new FileInputStream(dataDir + "alice29.txt")) {
        try (FileInputStream source2 = new FileInputStream(dataDir + "asyoulik.txt")) {
            try (Archive archive = new Archive(new ArchiveEntrySettings())) {
                archive.createEntry("alice29.txt", source1) ;
                archive.createEntry("asyoulik.txt", source2) ;
                ParallelOptions parallelOptions = new ParallelOptions() ;
                parallelOptions.setParallelCompressInMemory(ParallelCompressionMode.Always) ;
                ArchiveSaveOptions options = new ArchiveSaveOptions() ;
                options.setParallelOptions(parallelOptions) ;
                options.setEncoding(StandardCharsets.US_ASCII) ;
                options.setArchiveComment("Il y a deux poèmes du corpus Canterbury") ;
                archive.save(zipFile, options) ;
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}

Compression LZMA dans une archive ZIP

L’algorithme Lempel-Ziv-Markov chain (LZMA) est un algorithme utilisé pour effectuer une compression de données sans perte. LZMA utilise un algorithme de compression par dictionnaire, le flux compressé est un flux de bits. La compression LZMA dans l’archive ZIP permet aux conteneurs ZIP de contenir des entrées compressées LZMA. L’exemple de code suivant montre la mise en œuvre de la compression LZMA à l’aide de l’API Aspose.ZIP.

Étapes:Compression LZMA dans une archive ZIP à l’aide de Java

1. Ouvrez un flux de sortie de fichier avec le nom souhaité de votre fichier zip de sortie.
2. Créez une instance de la classe ArchiveEntrySettings et passez-lui une instance de la classe LzmaCompressionSettings.
3. Créez une instance de la classe Archive et transmettez-lui l’instance de ArchiveEntrySettings créée ci-dessus.
4. Ajoutez les fichiers de données à compresser via les chemins d’accès aux fichiers à l’aide de la méthode Archive.createEntry.
5. Zippez les fichiers de données à l’aide de la méthode Archive.save.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "LZMACompression_out.zip")) {
    try (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings()))) {
        archive.createEntry("sample.txt", dataDir + "sample.txt") ;
        archive.save(zipFile) ;
    }
} catch (IOException ignored) {
    System.out.println(ex) ;
}

Compression BZip2 dans une archive ZIP

Les paramètres de compression BZip2 permettent au conteneur ZIP de contenir des entrées compressées BZip2. L’exemple de code suivant montre la mise en œuvre de la compression BZip2 à l’aide de l’API Aspose.ZIP.

Étapes:Compression BZip2 dans une archive ZIP à l’aide de Java

1. Ouvrez un flux de sortie de fichier avec le nom souhaité de votre fichier zip de sortie.
2. Créez une instance de la classe ArchiveEntrySettings et passez-lui une instance de la classe Bzip2CompressionSettings.
3. Créez une instance de la classe Archive et transmettez-lui l’instance de ArchiveEntrySettings créée ci-dessus.
4. Ajoutez les fichiers de données à compresser via les chemins d’accès aux fichiers à l’aide de la méthode Archive.createEntry.
5. Zippez les fichiers de données à l’aide de la méthode Archive.save.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "Bzip2Compression_out.zip")) {
    try (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings()))) {
        archive.createEntry("sample.txt", dataDir + "sample.txt") ;
        archive.save(zipFile) ;
    }
} catch (IOException ignored) {
    System.out.println(ex) ;
}

Décompression des archives

Décompression d’une archive en un seul fichier

try (FileInputStream fs = new FileInputStream(dataDir + "CompressSingleFile_out.zip")) {
    try (Archive archive = new Archive(fs)) {
        int[] percentReady = new int[] {0} ;
        archive.getEntries().get(0).setExtractionProgressed(new Event<ProgressEventArgs>() {
            @Override
            public void invoke(Object sender, ProgressEventArgs progressEventArgs) {
                int percent = (int) ((100 * progressEventArgs.getProceededBytes())
                        / ((ArchiveEntry) sender).getUncompressedSize()) ;
                if (percent > percentReady[0])
                {
                    System.out.println(percent + "% decompressed") ;
                    percentReady[0] = percent ;
                }
            }
        }) ;
        archive.getEntries().get(0).extract(dataDir + "alice_extracted_out.txt") ;
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}

Décompression d’une archive contenant plusieurs fichiers

try (FileInputStream fs = new FileInputStream(dataDir + "CompressMultipleFiles_out.zip")) {
    StringBuilder sb = new StringBuilder("Les entrées sont : ") ;
    int[] percentReady = new int[] {0} ;
    ArchiveLoadOptions options = new ArchiveLoadOptions() ;
    options.setEntryListed(new Event<EntryEventArgs>() {
        @Override
        public void invoke(Object sender, EntryEventArgs entryEventArgs) {
            sb.append(entryEventArgs.getEntry().getName()).append(", ") ;
        }
    }) ;
    options.setEntryExtractionProgressed(new Event<ProgressEventArgs>() {
        @Override
        public void invoke(Object sender, ProgressEventArgs progressEventArgs) {
            int percent = (int) ((100 * progressEventArgs.getProceededBytes())
                    / ((ArchiveEntry) sender).getUncompressedSize()) ;
            if (percent > percentReady[0])
            {
                System.out.println(percent + "% compressed") ;
                percentReady[0] = percent ;
            }
        }
    }) ;
    try (Archive archive = new Archive(fs, options)) {
        System.out.println(sb.substring(0, sb.length() - 2)) ;
        try (FileOutputStream extracted = new FileOutputStream(dataDir + "alice_extracted_out.txt")) {
            try (InputStream decompressed = archive.getEntries().get(0).open()) {
                byte[] buffer = new byte[8192] ;
                int bytesRead ;
                while (0 < (bytesRead = decompressed.read(buffer, 0, buffer.length))) {
                    extracted.write(buffer, 0, bytesRead) ;
                }
                // Lecture du flux décompressé dans le fichier d'extraction.
            }
        }
        percentReady[0] = 0 ;
        archive.getEntries().get(1).extract(dataDir + "asyoulik_extracted_out.txt") ;
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}

Extraire une archive stockée sans compression

try (FileInputStream zipFile = new FileInputStream(dataDir + "StoreMultipleFilesWithoutCompression_out.zip")) {
    try (Archive archive = new Archive(zipFile )) {
        try (FileOutputStream extracted = new FileOutputStream(dataDir + "alice_extracted_store_out.txt")) {
            try (InputStream stored = archive.getEntries().get(0).open()) {
                byte[] buffer = new byte[8192] ;
                int bytesRead ;
                while (0 < (bytesRead = stored.read(buffer, 0, buffer.length))) {
                    extrait.write(buffer, 0, bytesRead) ;
                }
                // Lecture du flux stocké vers le fichier d'extraction.
            }
        }
        try (FileOutputStream extracted = new FileOutputStream(dataDir + "asyoulik_extracted_store_out.txt")) {
            try (InputStream stored = archive.getEntries().get(1).open()) {
                byte[] buffer = new byte[8192] ;
                int bytesRead ;
                while (0 < (bytesRead = stored.read(buffer, 0, buffer.length))) {
                    extrait.write(buffer, 0, bytesRead) ;
                }
                // Lecture du flux stocké vers le fichier d'extraction.
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex) ;
}