Java ZIP - ¿cómo descomprimir la carpeta?

Question

¿Hay algún código de muestra, cómo descomprimir parcialmente la carpeta de ZIP en mi directorio deseado? He leído todos los archivos de la carpeta "FOLDER" en una matriz de bytes, ¿cómo puedo recrear desde su estructura de archivos?

Answer 1

Debe obtener todas las entradas de su archivo zip:

Enumeration entries = zipFile.getEntries(); 

continuación itareting sobre esta enumeración obtener el ZipEntry de ella, comprobar si se trata de un directorio o no, y crear dirctrory o simplemente extraer una respectivly archivo .

Answer 2

Aquí está el código que estoy usando. Cambie BUFFER_SIZE para sus necesidades.

import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.util.zip.ZipEntry; 
import java.util.zip.ZipInputStream; 

public class ZipUtils 
{ 
    private static final int BUFFER_SIZE = 4096; 

    private static void extractFile(ZipInputStream in, File outdir, String name) throws IOException 
    { 
    byte[] buffer = new byte[BUFFER_SIZE]; 
    BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(new File(outdir,name))); 
    int count = -1; 
    while ((count = in.read(buffer)) != -1) 
     out.write(buffer, 0, count); 
    out.close(); 
    } 

    private static void mkdirs(File outdir,String path) 
    { 
    File d = new File(outdir, path); 
    if(!d.exists()) 
     d.mkdirs(); 
    } 

    private static String dirpart(String name) 
    { 
    int s = name.lastIndexOf(File.separatorChar); 
    return s == -1 ? null : name.substring(0, s); 
    } 

    /*** 
    * Extract zipfile to outdir with complete directory structure 
    * @param zipfile Input .zip file 
    * @param outdir Output directory 
    */ 
    public static void extract(File zipfile, File outdir) 
    { 
    try 
    { 
     ZipInputStream zin = new ZipInputStream(new FileInputStream(zipfile)); 
     ZipEntry entry; 
     String name, dir; 
     while ((entry = zin.getNextEntry()) != null) 
     { 
     name = entry.getName(); 
     if(entry.isDirectory()) 
     { 
      mkdirs(outdir,name); 
      continue; 
     } 
     /* this part is necessary because file entry can come before 
     * directory entry where is file located 
     * i.e.: 
     * /foo/foo.txt 
     * /foo/ 
     */ 
     dir = dirpart(name); 
     if(dir != null) 
      mkdirs(outdir,dir); 

     extractFile(zin, outdir, name); 
     } 
     zin.close(); 
    } 
    catch (IOException e) 
    { 
     e.printStackTrace(); 
    } 
    } 
} 

Answer 3

Lo mismo se puede lograr utilizando la biblioteca Ant Compress. Conservará la estructura de la carpeta.

Maven dependencia: -

<dependency> 
    <groupId>org.apache.ant</groupId> 
    <artifactId>ant-compress</artifactId> 
    <version>1.2</version> 
</dependency> 

Código de ejemplo: -

Unzip unzipper = new Unzip(); 
unzipper.setSrc(theZIPFile); 
unzipper.setDest(theTargetFolder); 
unzipper.execute(); 

Answer 4

No estoy seguro de lo que quiere usted decir con particaly? ¿Quiere decir hágalo usted mismo sin la ayuda de API?

En el caso de que no les importa usar alguna biblioteca de código abierto, hay una API fresco para que por ahí se llama zip4J

Es fácil de usar y creo que hay una buena retroalimentación al respecto. Vea este ejemplo:

String source = "folder/source.zip"; 
String destination = "folder/source/"; 

try { 
    ZipFile zipFile = new ZipFile(source); 
    zipFile.extractAll(destination); 
} catch (ZipException e) { 
    e.printStackTrace(); 
} 

Si los archivos que desea descomprimir tener contraseñas, se puede intentar esto:

String source = "folder/source.zip"; 
String destination = "folder/source/"; 
String password = "password"; 

try { 
    ZipFile zipFile = new ZipFile(source); 
    if (zipFile.isEncrypted()) { 
     zipFile.setPassword(password); 
    } 
    zipFile.extractAll(destination); 
} catch (ZipException e) { 
    e.printStackTrace(); 
} 

Espero que esto sea útil.

Answer 5

Aquí hay una solución fácil que sigue las convenciones más modernas. Es posible que desee cambiar el tamaño del búfer para que sea más pequeño si está descomprimiendo archivos más grandes. Esto es para que no guarde toda la información de los archivos en la memoria.

public static void unzip(File source, String out) throws IOException { 
    try (ZipInputStream zis = new ZipInputStream(new FileInputStream(source))) { 

     ZipEntry entry = zis.getNextEntry(); 

     while (entry != null) { 

      File file = new File(out, entry.getName()); 

      if (entry.isDirectory()) { 
       file.mkdirs(); 
      } else { 
       File parent = file.getParentFile(); 

       if (!parent.exists()) { 
        parent.mkdirs(); 
       } 

       try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file))) { 

        byte[] buffer = new byte[Math.toIntExact(entry.getSize())]; 

        int location; 

        while ((location = zis.read(buffer)) != -1) { 
         bos.write(buffer, 0, location); 
        } 
       } 
      } 
      entry = zis.getNextEntry(); 
     } 
    } 
} 

Answer 6

aquí es más "moderna" código completo basado en this puesto, pero refactorizado (y usando Lombok):

import lombok.experimental.var; 
import lombok.val; 

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.util.zip.ZipInputStream; 

import static java.nio.file.Files.createDirectories; 

public class UnZip 
{ 
    public static void unZip(String sourceZipFile, String outputDirectory) throws IOException 
    { 
     val folder = new File(outputDirectory); 
     createDirectories(folder.toPath()); 

     try (val zipInputStream = new ZipInputStream(new FileInputStream(sourceZipFile))) 
     { 
      var nextEntry = zipInputStream.getNextEntry(); 

      while (nextEntry != null) 
      { 
       val fileName = nextEntry.getName(); 
       val newFile = new File(outputDirectory + File.separator + fileName); 

       createDirectories(newFile.getParentFile().toPath()); 
       writeFile(zipInputStream, newFile); 

       nextEntry = zipInputStream.getNextEntry(); 
      } 

      zipInputStream.closeEntry(); 
     } 
    } 

    private static void writeFile(ZipInputStream inputStream, File file) throws IOException 
    { 
     val buffer = new byte[1024]; 
     try (val fileOutputStream = new FileOutputStream(file)) 
     { 
      int length; 
      while ((length = inputStream.read(buffer)) > 0) 
      { 
       fileOutputStream.write(buffer, 0, length); 
      } 
     } 
    } 
}