Il necessario per gestire file Zip in Java è contenuto all'interno del package java.util.zip. In questo package troviamo le classi ZipEntry, ZipFile, ZipInputStream e ZipOutputStream, attraverso le quali possiamo creare un archivio Zip oppure estrarre il contenuto di uno già esistente.
La classi ZipFile e ZipInputStream sono utilizzate per leggere il contenuto di un file Zip mentre la classe ZipEntry rappresenta un particolare file o directory all'interno del file. ZipOutputStream è invece utilizzata per scrivere in un file Zip.
Per creare ed estrarre il contenuto di un file Zip contente un determinato numero di file iniziamo con il presentare lo scheletro del programma dimostrativo:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
public class ZipDemo {
public static void main(String[] args) {
List<File> files = Arrays.asList(
new File("c:\\source\\adams04.jpg"),
new File("c:\\source\\adams05.jpg"),
new File("c:\\source\\adams06.jpg"));
zip("c:\\source\\test.zip", files);
unzip("c:\\source\\test.zip", "c:\\dest");
}
.....
}Il nostro obiettivo è duplice, realizzare un metodo che, ricevendo come in input il path di destinazione del file Zip e la lista di file da comprimere, esegua il lavoro di creazione dell'archivio e, successivamente, realizzare un metodo che si occupi dell'estrazione del file Zip ricevendo come input il path del file stesso e la directory di destinazione.
Il codice presentato fa riferimento a cartelle e file puramente indicativi, il lettore dell'articolo dovrà preliminarmente fare in modo che essi esistano, oppure crearne di nuovi aggiornando di conseguenza il codice per riferirsi correttamente ad essi. Il metodo zip() deve inizialmente creare gli stream per una lettura bufferizzata del contenuto del file Zip.
Realizziamo questa operazione avvalendoci del costrutto try-with-resources:
private static void zip(String zipFilePath, List<File> files) {
try (FileOutputStream outputStream = new FileOutputStream(zipFilePath);
ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutputStream);) {
.....
} catch (IOException e) {
e.printStackTrace();
}
}Successivamente implementiamo un blocco di iterazione sulla lista di file ricevuta in ingresso al fine di aggiungerli come contenuto del file Zip.
Implementiamo questa operazione attraverso il metodo forEach() ed una lambda expression:
private static void zip(String zipFilePath, List<File> files) {
try (FileOutputStream outputStream = new FileOutputStream(zipFilePath);
ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
BufferedOutputStream bufferOutStream = new BufferedOutputStream(zipOutputStream);) {
files.forEach(file -> {
byte[] buffer = new byte[1024];
try (FileInputStream fis = new FileInputStream(file);
BufferedInputStream bufferInStream = new BufferedInputStream(fis);) {
ZipEntry zipEntry = new ZipEntry(file.getName());
zipOutputStream.putNextEntry(zipEntry);
int bytes = 0;
while ((bytes = bufferInStream.read(buffer)) > 0) {
bufferOutStream.write(buffer, 0, bytes);
bufferOutStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
});
} catch (IOException e) {
e.printStackTrace();
}
}Anche in questo caso, per ciascun file, creiamo gli stream per la lettura del suo contenuto. Le classi ZipEntry e ZipOutputStream permettono l'inserimento del file corrente, inserimento finalizzato dalla scrittura sullo stream bufferizzato di output.
Vogliamo adesso estrarre il contenuto del file Zip scrivendo il codice che implementi il metodo unzip().
Per decomprimere il file decidiamo di fare uso della classe ZipFile, dichiarata anch'essa all'interno di un blocco try-with-resources, ottenendo successivamente da essa uno Stream Java:
private static void unzip(String zipFilePath, String destDirPath) {
try (ZipFile zipFile = new ZipFile(zipFilePath)) {
Stream<? extends ZipEntry> stream = zipFile.stream();
....
} catch (IOException e) {
e.printStackTrace();
}
}Proseguiamo inserendo il codice che recupera, attraverso il metodo forEach() ed una lambda expression, un file (zipEntry) dopo l'altro dallo stream di input:
private static void unzip(String zipFilePath, String destDirPath) {
try (ZipFile zipFile = new ZipFile(zipFilePath)) {
Stream<? extends ZipEntry> stream = zipFile.stream();
stream.forEach(zipEntry -> {
byte[] buffer = new byte[1024];
try (InputStream inputStream = zipFile.getInputStream(zipEntry);
BufferedInputStream bufferInStream = new BufferedInputStream(inputStream);
BufferedOutputStream bufferOutStream = new BufferedOutputStream(
new FileOutputStream(destDirPath + File.separator + zipEntry.getName()));) {
int bytes = 0;
while ((bytes = bufferInStream.read(buffer)) > 0) {
bufferOutStream.write(buffer, 0, bytes);
bufferOutStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
});
} catch (IOException e) {
e.printStackTrace();
}
}Anche in questo caso abbiamo bisogno di dichiarare gli stream necessari alla lettura e scrittura bufferizzata del file corrente rappresentato dall'oggetto zipEntry. Il contenuto del file viene infine salvato nel percorso di destinazione con lo stesso nome letto dall'archivio.
