Cómo comprimir y descomprimir archivos en Java

Visión general

Este artículo le enseñará a comprimir archivos Zip mediante programación utilizando diversos métodos con la API de Java y código de ejemplo. Aprenderá a comprimir uno o más archivos, así como a comprimir archivos simultáneamente. También aprenderá a descomprimir o descomprimir archivos.

Comprimir o descomprimir archivos en Java y descomprimir o descomprimir archivos en Java

La API Aspose.ZIP permite comprimir y descomprimir archivos sin preocuparse de la estructura de archivos subyacente. Este artículo muestra cómo trabajar con la compresión de archivos simples y múltiples.

Comprimir archivos

**Compresión de un solo archivo

Pasos: Comprimir un solo archivo en Java

1. Cree un flujo de salida de archivo con el nombre deseado de su archivo zip de salida.
2. Cree un flujo de entrada de archivos del archivo de datos a comprimir.
3. Crear una instancia de la clase Archive y pasarle una instancia de la clase ArchiveEntrySettings.
4. Añadir el fichero de datos creado en el paso 2 mediante el método Archive.createEntry.
5. 5. Comprima el archivo de datos utilizando el método Archive.save y pásele el flujo de archivos creado en el paso 1.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "CompressSingleFile_out.zip")) {
    //Archivo a añadir al archivo
    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);
}

Compresión de varios archivos

Pasos:Comprimiendo múltiples archivos en Java

1. Cree un flujo de archivos con el nombre deseado de su archivo zip de salida.
2. Crear flujo de archivos del primer archivo de datos a comprimir.
3. Crear flujo de archivos del segundo archivo de datos a comprimir.
4. Crear una instancia de la clase Archivo.
5. Añadir los ficheros de datos creados en los pasos 2 y 3 mediante el método Archive.createEntry.
6. Crear una instancia de la clase ArchiveSaveOptions.
7. Comprima los ficheros de datos utilizando el método Archive.save y pásele el flujo de ficheros creado en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.

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("Hay dos poemas del corpus Canterbury");
                archive.save(zipFile, options);
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex);
}

Comprimir archivos por información de archivo

Pasos:Comprimir archivos por información de archivo en Java

1. Abra un flujo de salida de archivos con el nombre deseado de su archivo zip de salida.
2. Cree el objeto Archivo de su primer archivo de datos a comprimir.
3. 3. Cree el objeto Fichero de su segundo fichero de datos a comprimir.
4. Crear una instancia de la clase Archivo.
5. Añade los ficheros de datos creados en los pasos 2 y 3 mediante el método Archive.createEntry.
6. Crear una instancia de la clase ArchiveSaveOptions.
7. 7. Comprima los ficheros de datos utilizando el método Archive.save y pásele el flujo de ficheros creado en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.

try (FileOutputStream zipFile = new FileOutputStream(dataDir + "CompressFilesByFileInfo_out.zip")) {
    File fi1 = new File(dataDir + "alice29.txt");
    Archivo fi2 = nuevo Archivo(dataDir + "fields.c");
    try (Archivo archive = nuevo Archivo()) {
        archive.createEntry("alice29.txt", fi1);
        archive.createEntry("campos.c", fi2);
        ArchiveSaveOptions options = new ArchiveSaveOptions();
        options.setEncoding(StandardCharsets.US_ASCII);
        archive.save(zipFile, options);
    }
} catch (IOException ignorada) {
    System.out.println(ex);
}

Almacenamiento de ficheros en archivos sin compresión

Pasos: Almacenamiento de archivos a archivos sin compresión usando Java

1. Abra un flujo de salida de archivos con el nombre deseado de su archivo zip de salida.
2. Cree objetos Archivo para sus ficheros de datos que se almacenarán en el archivo.
3. 3. Crear una instancia de la clase ArchiveEntrySettings y pasarle una instancia de la clase StoreCompressionSettings.
4. Crear una instancia de la clase Archive y pasarle la instancia de la clase ArchiveEntrySettings creada en el paso anterior.
5. Añada los objetos File creados en el paso 2 utilizando el método Archive.createEntry.
6. Crear una instancia de ArchiveSaveOptions y establecer la codificación a StandardCharsets.US_ASCII utilizando el método ArchiveSaveOptions.setEncoding.
7. 7. Comprima los archivos de datos utilizando el método Archive.save y pásele el flujo de archivos creado en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.

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

Usando Paralelismo para Comprimir Ficheros

Pasos: Usando Paralelismo para Comprimir Ficheros usando Java

1. Abra un flujo de salida de archivos con el nombre deseado de su archivo zip de salida.
2. Abra flujos de entrada de archivos para su primer y segundo archivo de datos a comprimir.
3. Cree una instancia de la clase Archive.
4. Añada los ficheros de datos creados en el paso 2 utilizando el método Archive.createEntry.
5. 5. Crear una instancia de ParallelOptions y establecer ParallelCompressionMode.Always utilizando el método ParallelOptions.setParallelCompressInMemory.
6. Crear una instancia de ArchiveSaveOptions y establecer las opciones paralelas con la instancia anterior utilizando el método ArchiveSaveOptions.setParallelOptions.
7. 7. Comprima los archivos de datos utilizando el método Archive.save y pásele el flujo de archivos creado en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.

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("Hay dos poemas del corpus Canterbury");
                archive.save(zipFile, options);
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex);
}

Compresión LZMA dentro de un archivo ZIP

El algoritmo de cadena Lempel-Ziv-Markov (LZMA) es un algoritmo utilizado para realizar compresión de datos sin pérdidas. LZMA utiliza un algoritmo de compresión de diccionario, el flujo comprimido es un flujo de bits. La compresión LZMA dentro del archivo ZIP permite que los contenedores ZIP contengan entradas comprimidas con LZMA. El siguiente ejemplo de código muestra la implementación de la compresión LZMA utilizando la API Aspose.ZIP.

Pasos: Compresión LZMA dentro de un archivo ZIP usando Java

1. Abra un flujo de salida de archivos con el nombre deseado de su archivo zip de salida.
2. Crear una instancia de la clase ArchiveEntrySettings y pasarle una instancia de la clase LzmaCompressionSettings.
3. Cree una instancia de la clase Archive y pásele la instancia de ArchiveEntrySettings creada anteriormente.
4. Añadir los ficheros de datos a comprimir mediante rutas de fichero utilizando el método Archive.createEntry.
5. 5. Comprima los ficheros de datos utilizando el método Archive.save.

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

Compresión BZip2 dentro de un archivo ZIP

La configuración de compresión BZip2 permite que el contenedor ZIP contenga entradas comprimidas con BZip2. El siguiente ejemplo de código muestra la implementación de la compresión BZip2 utilizando Aspose.ZIP API.

Pasos: Compresión BZip2 dentro de un archivo ZIP usando Java

1. Abra un flujo de salida de archivos con el nombre deseado de su archivo zip de salida.
2. 3. Crear una instancia de la clase ArchiveEntrySettings y pasarle una instancia de la clase Bzip2CompressionSettings.
3. Crear una instancia de la clase Archive y pasarle la instancia de ArchiveEntrySettings creada anteriormente.
4. Añadir los ficheros de datos a comprimir mediante rutas de fichero utilizando el método Archive.createEntry.
5. 6. Comprima los ficheros de datos utilizando el método Archive.save.

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

Descompresión de archivos

**Descomprimir archivo con un solo fichero

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(porcentaje + "% descomprimido");
                    percentReady[0] = porcentaje;
                }
            }
        });
        archive.getEntries().get(0).extract(dataDir + "alice_extracted_out.txt");
    }
} catch (IOException ex) {
    System.out.println(ex);
}

Descomprimir archivo con varios ficheros

try (FileInputStream fs = new FileInputStream(dataDir + "CompressMultipleFiles_out.zip")) {
    StringBuilder sb = new StringBuilder("Las entradas son: ");
    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(porcentaje + "% comprimido");
                percentReady[0] = porcentaje;
            }
        }
    });
    try (Archivo = nuevo Archivo(fs, opciones)) {
        System.out.println(sb.substring(0, sb.length() - 2));
        try (FileOutputStream extracted = new FileOutputStream(dataDir + "alice_extracted_out.txt")) {
            try (InputStream descomprimido = archive.getEntries().get(0).open()) {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.read(buffer, 0, buffer.length)) {
                    extraído.escribir(búfer, 0, bytesRead);
                }
                // Leer del flujo descomprimido al archivo extraído.
            }
        }
        percentReady[0] = 0;
        archive.getEntries().get(1).extract(dataDir + "asyoulik_extracted_out.txt");
    }
} catch (IOException ex) {
    System.out.println(ex);
}

Extraer archivo almacenado sin compresión

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)) {
                    extraído.escribir(búfer, 0, bytesRead);
                }
                // Leer del flujo almacenado al archivo extraído.
            }
        }
        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)) {
                    extraído.escribir(búfer, 0, bytesRead);
                }
                // Leer del flujo almacenado al archivo extraído.
            }
        }
    }
} catch (IOException ex) {
    System.out.println(ex);
}