Como Comprimir Archivos Zip En Java

En el capitulo de hoy vamos a ver como comprimir archivos en formato ZIP. Si bien a
veces tenemos files que no se pueden comprimir demasiado siempre es muy util zipear
archivos agrupandolos en un gran archivo.
El codigo para la compresion.
String inputFile = "c:/myfile.txt";
FileInputStream in = new FileInputStream(inputFile);
FileOutputStream out = new FileOutputStream("c:/myzip.zip");
byte b[] = new byte[2048];
ZipOutputStream zipOut = new ZipOutputStream(out);
ZipEntry entry = new ZipEntry(inputFile);
zipOut.putNextEntry(entry);
int len = 0;
while ((len = in.read(b)) != -1) {
zipOut.write(b, 0, len);
}
zipOut.closeEntry();
zipOut.close();

Otro codigo para lo mismo

import java.util.zip.*;
import java.io.*;
/**
*
* @author GeekZero
*/
public class Archivos {
private static final int BUFFER_SIZE = 1024;
public void Zippear(String pFile, String pZipFile) throws
Exception {
// objetos en memoria
FileInputStream fis = null;
FileOutputStream fos = null;
ZipOutputStream zipos = null;
// buffer
byte[] buffer = new byte[BUFFER_SIZE];
try {
// fichero a comprimir
fis = new FileInputStream(pFile);
// fichero contenedor del zip
fos = new FileOutputStream(pZipFile);
// fichero comprimido
zipos = new ZipOutputStream(fos);
ZipEntry zipEntry = new ZipEntry(pFile);
zipos.putNextEntry(zipEntry);
int len = 0;

// zippear
while ((len = fis.read(buffer, 0, BUFFER_SIZE))

!= -1)

zipos.write(buffer, 0, len);
// volcar la memoria al disco
zipos.flush();
} catch (Exception e) {
throw e;
} finally {
// cerramos los files
zipos.close();
fis.close();
fos.close();
} // end try
} // end Zippear
public void UnZip(String pZipFile, String pFile) throws
Exception {
BufferedOutputStream bos = null;
FileInputStream fis = null;
ZipInputStream zipis = null;
FileOutputStream fos = null;
try {

fis = new FileInputStream(pZipFile);

zipis = new ZipInputStream(new
BufferedInputStream(fis));
if (zipis.getNextEntry() != null) {
int len = 0;
byte[] buffer = new byte[BUFFER_SIZE];
fos = new FileOutputStream(pFile);
bos = new BufferedOutputStream(fos,
BUFFER_SIZE);
while
BUFFER_SIZE)) != -1)

fichero alguno");

((len = zipis.read(buffer, 0,

bos.write(buffer, 0, len);
bos.flush();
} else {
throw new Exception("El zip no contenia

} // end if
} catch (Exception e) {
throw e;
} finally {
bos.close();
zipis.close();
fos.close();
fis.close();
} // end try
} // end UnZip
// ejemplo de uso
public static void main(String[] args) throws Exception {
try {
Archivos arch = new Archivos();
arch.Zippear("devtroce.jpg", "devtroce.zip");
System.out.println("Comprimido!");
arch.UnZip("devtroce.zip", "new_devtroce.jpg");
System.out.println("Descomprimido!");
} catch (Exception e) {

e.printStackTrace();
}
}// end class

Otrooooooo mtodo

codigo comprimir ficheros zip en java sin contrasea tutorial

hola muchachos como estan navegando en la web casi no encontre muchos tutoriales de
como comprimir archivos en java con contrasea y sin contrasea hoy les enseo en
varias entradas como comprimir archivos sin contrasea y con contrasea utilizando la
plataforma de netbeans en java empezemos :) :
para comprimir archivos debemos descargar la siguiente libreria:
Descargar libreria
luego aadimos la libreria .jar dando click derecho a la carpeta biblioteca-->agregar
archivo jar
despues de eso vamos a crear una nueva clase yo la voy a llamar add_a_un_zip y
agregamos el siguiente codigo:

import java.io.File;
import java.util.ArrayList;
import
import
import
import

net.lingala.zip4j.core.ZipFile;
net.lingala.zip4j.exception.ZipException;
net.lingala.zip4j.model.ZipParameters;
net.lingala.zip4j.util.Zip4jConstants;

/**
*
* @author andres2288
*/
//aadir un archivo al zip pero tambien puede crear el zip desde cero
public class add_a_un_zip {
public add_a_un_zip () {

try {
ZipFile zipFile = new
ZipFile("C:/Users/andres2288/Documents/compression/andres2288.zip");
ArrayList filesToAdd = new ArrayList();
filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/ZipTest/sample.txt"));
ZipParameters parameters = new ZipParameters();
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); //
set compression method to deflate compression

parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
zipFile.addFiles(filesToAdd, parameters);
} catch (ZipException e) {
e.printStackTrace();
}

public static void main(String[] args) {

new add_a_un_zip ();
}
}

tenemos el constructor por defecto y ahy ponemos el codigo ay una exception catch
pero ojo no es de netbeans es de la libreria zip por defecto por eso a la hora de crear un
codigo podemos equivocarnos en la exception ya que no es Exception e si no que
es ZipException e , en el codigo utilizamos un ArrayList para agregar cuantos archivos
queramos y definimos parameters d ela libreria para poner parametros al comprimir
como por ejemplo el nivel de compresion si maximo ,normal o bajo y que sea constante,
en la parte donde dice ZipFile zipFile = new
ZipFile("C:/Users/andres2288/Documents/compression/andes2288.zip"); es la ruta
donde se creara el nuevo archivo comprimido o el existente andres2288.zip sera el
nuevo archivo o si ya existe comprimira dentro el archivo de texto plano, donde dice
filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/ZipTest/sample.txt")); es el
archivo a comprimir pueden comprimir cualquier cosa que ustedes quieran hasta un
archivo mp3 y pueden agregar mas archivos repitiendo esa linea eso es todo :)

aadir una carpeta a un archivo comprimido con java

bueno muchachos a veces nesesitamos agregar una carpeta que este en el entorno de
windows a un archivo comprimido zip este codigo es solo para agregar carpetas vacias
en otra entrada es para agregar una carpeta con archivos por dentro primero debemos
crear una nueva clase la vamos a llamar aadir_solo_una_carpeta
el codigo es el siguiente y a lo ultimo la libreria pa que la descarguen:

import
import
import
import
import
import

java.io.File;
java.util.ArrayList;
net.lingala.zip4j.core.ZipFile;
net.lingala.zip4j.exception.ZipException;
net.lingala.zip4j.model.ZipParameters;
net.lingala.zip4j.util.Zip4jConstants;

/**
*
* @author andres2288
*/
public class aadir_solo_una_carpeta {
//aade archivos externos al comprimido pero creando una carpeta
deseada una chimba
public aadir_solo_una_carpeta () {
try {
ZipFile zipFile = new
ZipFile("C:/Users/andres2288/Documents/compression/andres2288.zip");
ArrayList filesToAdd = new ArrayList();
filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/soy_una_carpeta"));
ZipParameters parameters = new ZipParameters();
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); //
set compression method to deflate compression
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
parameters.setRootFolderInZip("agregado/");
zipFile.addFiles(filesToAdd, parameters);
} catch (ZipException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new aadir_solo_una_carpeta ();
}

donde dice ZipFile zipFile = new

ZipFile("C:/Users/andres2288/Documents/compression/andes2288.zip"); es el
archivo que se va a comprimir puede empezar desde cero o puede que ya exista el
archivo donde dice filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/soy_una_carpeta")); es una
carpeta que esta en el entorno de windows y donde dice
parameters.setRootFolderInZip("agregado/"); es una nueva carpeta a la que ustedes
le pueden dar el nombre que ustedes quieran agregado pueden cambiarlo por cualquier
nombre ustedes pueden jugar con eso para sus respectivas aplicaciones.

codigo comprimir archivos con contrasea utilizando java

bueno muchachos aqui ay varias entradas donde utilizamos varias funciones de esta
libreria la libreria al final les dejo el link de descarga el siguiente codigo es para
comprimir archivos con java y ponerles contrasea para seguridad solo le pone
contrasea al archivo que ustedes desean comprimir el resto no pero sin embargo
pueden comprimir los archivos que ustedes quieran ya que utilizamos un ArrayList
ustedes pueden jugar con esta libreria tiene varias funciones y se las ire explicando en
cada entrada:
lo primero que debemos hacer es crear una nueva clase esta la
llamaremos add_a_un_zip_con_contrasea
y en esa clase ponemos el siguiente codigo:

import
import
import
import
import
import

java.io.File;
java.util.ArrayList;
net.lingala.zip4j.core.ZipFile;
net.lingala.zip4j.exception.ZipException;
net.lingala.zip4j.model.ZipParameters;
net.lingala.zip4j.util.Zip4jConstants;

public class add_a_un_zip_con_contrasea {

public add_a_un_zip_con_contrasea () {
try {
ZipFile zipFile = new
ZipFile("C:/Users/andres2288/Documents/compression/andes2288.zip");
ArrayList filesToAdd = new ArrayList();
filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/ZipTest/sample.txt"));

ZipParameters parameters = new ZipParameters();

parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); //
set compression method to deflate compression

parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
parameters.setEncryptFiles(true);
parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_AES);
parameters.setAesKeyStrength(Zip4jConstants.AES_STRENGTH_256);
parameters.setPassword("123");
zipFile.addFiles(filesToAdd, parameters);
} catch (ZipException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new add_a_un_zip_con_contrasea ();
}
}

en donde dice ZipFile zipFile = new

ZipFile("C:/Users/andres2288/Documents/compression/andres2288.zip"); es el
archivo nuevo que vamos a comprimir puede que no exista como que puede existir,
donde dice
filesToAdd.add(new
File("C:/Users/andres2288/Documents/compression/ZipTest/sample.txt")); es el
archivo de texto que voy a comprimir es la ruta donde se encuentra ese archivo igual
que arriba y va ser un archivo de texto plano ustedes pueden comprimir el que quieran
igual pueden agregar mas archivos repitiendo la linea, en donde dice
parameters.setPassword("123"); es la contrasea que vamos a insertar para
comprimir y eso es todo alguna pregunta puedes comentarla :)

copiar ficheros de un lugar a otro con java

import
import
import
import
import
import

java.io.File;
java.io.FileInputStream;
java.io.FileOutputStream;
java.io.IOException;
java.io.InputStream;
java.io.OutputStream;

public class CopiarFicheros {

public static void main(String[] args) {

File origen = new

File("C:\\Users\\gatu\\Desktop\\prueba.txt");
File destino = new
File("C:\\Users\\gatu\\Desktop\\arbol\\prueba.txt");
try {

InputStream in = new FileInputStream(origen);

OutputStream out = new
FileOutputStream(destino);
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
} catch (IOException ioe){
ioe.printStackTrace();
}
}
}

reproductor reproducir musica en java

bueno aqui les pondre un codigo para que reproduscan musica con java primeros
creamos un pakete llamado reproductor y dentro de ese pakete una nueva nueva clase yo
la llamare Reproductor en en esa clase pongo el siguiente codigo:
package reproductor;
import java.io.File;
import javazoom.jlgui.basicplayer.BasicPlayer;
public class Reproductor {
public BasicPlayer player;
public Reproductor() {
player = new BasicPlayer();
}
public void coge(String y){
}
public void Play() throws Exception {
player.play();
}
public void AbrirFichero(String ruta) throws Exception {

player.open(new File(ruta));
}
public void Pausa() throws Exception {
player.pause();
}
public void Continuar() throws Exception {
player.resume();
}
public void Stop() throws Exception {
player.stop();
}
public void reproducemp3 () throws Exception{
try {
Reproductor
mi_reproductor = new Reproductor();
mi_reproductor.AbrirFichero("C:/Users/Public/Music/Sample
Music/Kalimba.mp3");
mi_reproductor.Play();
} catch (Exception ex) {
System.out.println("Error: " + ex.getMessage());
}
}
public static void main(String args[]) throws Exception{
Reproductor y = new Reproductor();
y.AbrirFichero("C:/Users/Public/Music/Sample Music/Kalimba.mp3");
y.Play();
}
}

luego descargan estos 2 archivos que estan en la parte de abajo y los ponen importan
como bibliotecas y listo full para poder hacer un reproductor de musica

Crear un archivo comprimido Zip con Java

Comprimir cierto tipo de archivos como los archivos de texto puede suponer un
considerable reduccin del tamao del archivo original, un xml del 20 MiB se puede
quedar en 1.5 MiB, es decir, una tasa de compresin de 13 o lo que es lo mismo el
fichero comprimido ocupa 13 veces menos. Esto es muy interesante en las aplicaciones
web ya que puede ayudar a ahorrar ancho de banda y reducir los tiempos de descarga
del archivo. La compresin se hace a costa de cargar la CPU con trabajo pero
normalmente el tiempo global que se tarda en descargar el archivo suele ser menor
comprimiendo ya que el mayor limitante suele ser el ancho de banda de la red y no la
carga de la CPU. Otra ventaja para las aplicaciones web es que algunos formatos

adems de comprimir pueden contener varios archivos y por tanto haciendo uso de ellos
se pueden devolver un archivo pero que contiene a varios en una sola peticin.
Java proporciona una serie de clases para trabajar con archivos comprimidos en formato
zip y su uso no es muy complicado. Aqu el cdigo para generar un archivo zip con la
Api de Java y guardando en l dos archivos.

OutputStream os = ...;
ZipOutputStream zos = new ZipOutputStream(os);

zos.putNextEntry(new ZipEntry("Archivo 1.xml"));

zos.write(...);
zos.closeEntry();

zos.putNextEntry(new ZipEntry("Archivo 2.xml"));

zos.write(...);
zos.closeEntry();

zos.close();

Zip en java: Comprimir archivos y/o directorios

Ejemplo claro y conciso para hacer un archivo zip con las librerias de java. El siguente
cdigo sirve tambin para hacer un archivo zip de un directorio con todo su contenido,
el cual es agregado de manera recursiva.

A continuacin copio y pego el cdigo tal cual pero agrego el enlace de donde lo
recuper.
001
002
003
004
005
006
007
008
009
010
011
012
013
014

import java.io.*;
import java.util.zip.*;
/**
* Compresses a file or directory into a Zip archive. Users of the
* class supply the name of the file or directory as an argument.
*/
public class SimpleZip {
private static ZipOutputStream zos;
public static void main(String[] args) {
//User must specify a directory to compress

015
016
017
018 if (args.length < 1) {
019
System.out.println("Usage: java SimpleZip directoryName");
020
System.exit(0);
021
}
022
//Get the name of the file or directory to compress.
023
024
025
026
027 String fileName = args[0];
028
//Use the makeZip method to create a Zip archive.
029
030
031 try {
032
makeZip(fileName);
033
}
034
//Simply print out any errors we encounter.
035
036
037 catch (Exception e) {
038
System.err.println(e);
039
}
040
}
041
042
/**
043
* Creates a Zip archive. If the name of the file passed in is a
* directory, the directory's contents will be made into a Zip
044
file.
045
*/
046
public static void makeZip(String fileName)
047
throws IOException, FileNotFoundException
048
{

049

File file = new File(fileName);

zos = new ZipOutputStream(new FileOutputStream(file +
050
".zip"));
051
//Call recursion.
052
053
054 recurseFiles(file);
055
//We are done adding entries to the zip archive,
056
057
058 //so close the Zip output stream.
059
060
061 zos.close();
062
}
063
064
/**
065
* Recurses down a directory and its subdirectories to look for
066
* files to add to the Zip. If the current file being looked at
067
* is not a directory, the method adds it to the Zip file.
068
*/
069
private static void recurseFiles(File file)
070
throws IOException, FileNotFoundException
071
{
072
if (file.isDirectory()) {
//Create an array with all of the files and
073
subdirectories
074 //of the current directory.
075 String[] fileNames = file.list();
076
if (fileNames != null) {
//Recursively add each array entry to make sure that we
077
get
//subdirectories as well as normal files in the
078
directory.
079
for (int i=0; i<filenames.length; i++){
080
recursefiles(new File(file, fileNames[i]));
081
}
082
}
083
}
//Otherwise, a file so add it as an entry to the Zip
084
file.
085 else {
086
byte[] buf = new byte[1024];
087
int len;
088
//Create a new Zip entry with the file's name.
089
090
091 ZipEntry zipEntry = new ZipEntry(file.toString());
092
//Create a buffered input stream out of the file
093
094
095 //we're trying to add into the Zip archive.

096
097
098 FileInputStream fin = new FileInputStream(file);
099
BufferedInputStream in = new BufferedInputStream(fin);
100
zos.putNextEntry(zipEntry);
//Read bytes from the file and write into the Zip
101
archive.
102
103
104 while ((len = in.read(buf)) >= 0) {
105
zos.write(buf, 0, len);
106
}
107
//Close the input stream.
108
109
110
111
112
113
114
115
116
117 }

in.close();
//Close this entry in the Zip stream.

zos.closeEntry();
}
}

El mtodo que hace toda la magia es makeZip(String fileName) el cual hace un archivo zip
de nombre fileName+".zip" del respectivo archivo o directorio.
Agrego aqu el link donde se recupera esta pieza de codigo, adems de que hace una
explicacin de el uso de las librerias zip y gzip en java. Clic aqui (Ahora pide que te
registres para poder acceder al artculo).
Algo con lo que he tenido complicacin es en crear un archivo jar usando estas libreras,
no he encontrado como hacer un jar que sea reconocido al momento de agregarlo al
classpath y ejecutar la aplicacin java, si alguien tiene algn ejemplo al respecto le
agradecera cualquier comentario.

Crear un fichero zip

Vamos a ver un ejemplo sencillo de cmo crear un fichero zip usando java. Para el
ejemplo, tendremos un fichero.txt con un trozo de texto y lo vamos a empaquetar en un
fichero.zip. Usaremos las clases que nos proporciona java en su paquete java.util.zip
En primer lugar creamos un OutputStream para nuestro fichero zip, de forma que
podamos ir poniendo en l nuestros ficheros comprimidos. Este OutputStream se
obtiene instanciando un ZipOutputStream
ZipOutputStream os = new ZipOutputStream(new
FileOutputStream("fichero.zip"));

Podemos indicar el nivel y tipo de compresin que queremos con los mtodos
setMethod() y setLevel() de la clase ZipOutputStream. Los valores que admiten estos
parmetros. Los dejaremos en sus valores por defecto que son DEFLATED para
setMethod() (es el algoritmo por defecto) y setLevel() con
DEFAULT_COMPRESSION, ambas constantes definidas en la clase Deflater
// Estas son las opciones por defecto, no es
// necesario ponerlas en codigo.
os.setLevel(Deflater.DEFAULT_COMPRESSION);
os.setMethod(Deflater.DEFLATED);

Una vez hecho esto, slo debemos ir aadiendo ficheros. Para ello, los pasos que hay
que dar son

Indicarle a ZipOutputStream que comenzamos una nueva entrada (un nuevo

fichero)
Pasarle los bytes de esa nueva entrada (del fichero). Se pasan sin comprimir y ya
se encargar de ir comprimindolos segn los metemos.
Indicarla a ZipOutputStream que terminamos la nueva entrada.
Repetir los pasos anteriores mientras queramos seguir metiendo ficheros

Para indicarle a ZipOutputStream que comenzamos a meter un nuevo fichero, ponemos

ZipEntry entrada = new ZipEntry("fichero.txt");
os.putNextEntry(entrada);

El nombre que usemos en ZipEntry es el nombre que queramos que tenga el fichero
dentro del zip. Aunque es lo habitual, no tiene por qu coincidir con el nombre del
fichero fuera del zip. Si queremos que el fichero comprimido est dentro de un
directorio en el zip, bastar con poner tambin el path donde lo queremos
ZipEntry entrada = new ZipEntry("directorio/fichero.txt");
os.putNextEntry(entrada);

Ahora hay que ir leyendo el fichero normal y pasndole los bytes al ZipOutputStream
FileInputStream fis = new FileInputStream("fichero.txt");
byte [] buffer = new byte[1024];
int leido=0;
while (0 < (leido=fis.read(buffer))){
os.write(buffer,0,leido);
}

Smplemente abrimos el fichero normal con un FileOutputStream, creamos un buffer de

lectura de 1024 bytes (o el tamao que consideremos adecuado) y nos metemos en un
bucle para ir leyendo y escribiendo en el ZipOutputStream.
Una vez que hemos terminado de leer y meter bytes de este fichero, cerramos tanto el
fichero como la entrada del zip, indicando as a ZipOutputStream que hemos terminado
con este fichero.
fis.close();
os.closeEntry();

repetimos el proceso con todos los ficheros que queramos seguir aadiendo, creando
para cada uno de ellos un nuevo ZipEntry, escribiendo los bytes del fichero y cerrando
el ZipEntry.
Una vez que acabemos con todos los ficheros, smplemente cerramos el
ZipOutputStream
os.close();

Leer y extraer un fichero zip

Si ya tenemos el fichero zip y lo que queremos es leer su contenido y extraerlo,
usaremos la clase ZipInputStream pasndole el fichero zip
ZipInputStream zis = new ZipInputStream(new
FileInputStream("fichero.zip"));

Esta clase tiene mtodos para consultar cuntas entradas tiene, cuales son, etc. En este
ejemplo que pretende ser sencillo, vamos smplemente a ir recorriendo y extrayendo
todas las entradas. Para ir recorriendo las entradas
ZipEntry entrada;
while (null != (entrada=zis.getNextEntry()) ){
System.out.println(entrada.getName());
...
}

A cada ZipEntry podremos interrogarle para saber su tamao, formato de compresin,

etc, etc. Basta ver la API de ZipEntry para ver las posibilidades.
Aprovechamos el mismo bucle para ir extrayendo los ficheros
ZipEntry entrada;
while (null != (entrada=zis.getNextEntry()) ){
System.out.println(entrada.getName());

FileOutputStream fos = new FileOutputStream(entrada.getName());

int leido;
byte [] buffer = new byte[1024];
while (0<(leido=zis.read(buffer))){
fos.write(buffer,0,leido);
}
fos.close();
zis.closeEntry();

Para cada entrada, creamos un FileOutputStream donde escribiremos el fichero

descomprimido. Aqu hemos puesto alegremente new
FileOutputStream(entrada.getName()), pero en realidad debemos analizar previamente
el entrada.getName() para ver si es el nombre de un fichero vlido que podamos
escribir. Por ejemplo, si como vimos al escribir el zip, el nombre de la entrada fuera

"directorio/fichero.txt", antes de abrir deberamos crear el directorio u obtendremos un

error.
Luego, simplemente se declara un buffer de lectura y nos metemos en un bucle hasta fin
de fichero, leyendo del ZipInputStream y escribiendo en el FileOutputStream.
Terminado el trasiego, cerramos el FileOutputStream y le indicamos a ZipInputStream
que hemos terminado con la entrada, llamando a closeEntry().
Y una vez que salgamos del bucle de entradas (no queden ms entradas en el zip),
cerramos el ZipOutputStream
zip.close();