Comprimir archivos en Java: Una guía práctica para manejar archivos .zip 📦

¡Hola, desarrolladores! En el desarrollo de aplicaciones, la compresión de archivos es una tarea común, ya sea para reducir el tamaño de los datos o para empaquetar varios archivos en uno solo. Aunque Java ha evolucionado, las bases de la compresión de archivos siguen siendo relevantes. Recientemente, me encontré con un código que escribí hace unos años para comprimir directorios en un archivo .zip, y me di cuenta de que sigue siendo una solución válida y funcional.

En este artículo, te voy a mostrar cómo puedes implementar esta lógica en Java, utilizando las clases nativas para manejar archivos comprimidos.

---

La lógica detrás de la compresión

La solución que te muestro aquí se basa en tres métodos principales:

1. zipDir: Este método principal inicia el proceso. Recibe la ruta del directorio que se quiere comprimir y coordina las demás operaciones.

2. generateFileList: Este es un método recursivo que se encarga de recorrer todo el directorio (y sus subdirectorios) para crear una lista de todos los archivos que se deben incluir en el .zip.

3. zipIt: Este método es el que realmente ejecuta la compresión. Utiliza la lista de archivos generada en el paso anterior para crear un archivo .zip y agregar cada uno de los archivos.

---

El código paso a paso

1. Método Principal: zipDir

Este método es el punto de entrada de la funcionalidad.

public void zipDir(String path) {
    // Lista para almacenar las rutas de los archivos
    List<String> fileList = new ArrayList<>();
    
    // Genera la lista de archivos a comprimir
    generateFileList(new File(path), path, fileList);
    
    // Inicia el proceso de compresión
    zipIt(path, fileList);   
}

2. Generar la lista de archivos: generateFileList

Este método recorre el árbol de directorios y subdirectorios de manera recursiva, añadiendo la ruta de cada archivo a una lista.

 public void generateFileList(File node, String sourcePath, List<String> fileList){
    if (node.isFile()) {
        // Genera la ruta relativa del archivo para el ZIP
        String zipEntry = node.getPath().substring(sourcePath.length() + 1);
        fileList.add(zipEntry);
    }
    
    if (node.isDirectory()) {
        String[] subNotes = node.list();
        if (subNotes != null) {
            for (String filename : subNotes) {
                // Llamada recursiva para procesar subdirectorios
                generateFileList(new File(node, filename), sourcePath, fileList);
            }
        }
    }
}

3. Comprimir el directorio: zipIt

Este es el método clave que utiliza ZipOutputStream para crear el archivo comprimido y agregar cada archivo de la lista.

 public void zipIt(String path, List<String> fileList) {
    byte[] buffer = new byte[1024];
    
    try (FileOutputStream fos = new FileOutputStream(path + ".zip");
         ZipOutputStream zos = new ZipOutputStream(fos)) {

        System.out.println("Creando archivo ZIP: " + path + ".zip");

        for (String file : fileList) {
            System.out.println("Añadiendo archivo: " + file);
            
            ZipEntry ze = new ZipEntry(file);
            zos.putNextEntry(ze);

            try (FileInputStream in = new FileInputStream(path + File.separator + file)) {
                int len;
                while ((len = in.read(buffer)) > 0) {
                    zos.write(buffer, 0, len);
                }
            }
            zos.closeEntry();
        }

        System.out.println("Directorio comprimido exitosamente.");
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

Análisis del código:

• ZipOutputStream: Es la clase principal para escribir datos en un archivo .zip.

• ZipEntry: Representa un archivo o directorio dentro del archivo .zip. Es crucial definir la ruta correcta del archivo para que la estructura de directorios se mantenga dentro del .zip.

• try-with-resources: El uso de esta estructura en Java 7+ garantiza que los recursos (FileOutputStream, ZipOutputStream, FileInputStream) se cierren automáticamente, lo que previene fugas de recursos.

---

Conclusión

Aunque existen librerías de terceros que simplifican estas tareas, entender el funcionamiento de las clases nativas de Java te da un control total sobre el proceso de compresión y te ayuda a resolver problemas de manera más eficiente.

¿Te ha sido útil este código? ¡Comparte tu experiencia en los comentarios y cuéntanos qué otras formas de compresión has usado en tus proyectos!