Si utiliza el kit de herramientas de compresión que viene con Java para implementar la función de descomprimir archivos a la carpeta especificada, porque el zip proporcionado por JDK solo puede procesarse en formato UTF-8, y el nombre del archivo en el sistema Windows está codificado en GBK, Entonces, si se descompone un paquete zip que contiene el nombre del archivo chino, y, por lo tanto, informará una excepción de parámetros ilegales. java y zipoutputstream.java.
Desde J2SE 1.4, el compilador Java ya no admite importar clases o interfaces para nombres de paquetes sin nombre, por lo que en el proyecto Java que crea, debe crear un nuevo paquete que define. del nombre de dominio de la escuela +su propio nombre de red, como cn.edu.xidian.crytoll.
Cree una nueva clase DeFlAterOutputStream en el paquete, el código es el siguiente:
DeFlAterOutputStream.java:
La copia del código es la siguiente:
paquete cn.edu.xdian.crytoll;
import java.io.filterOutputStream;
import java.io.ioException;
import java.io.outputstream;
import java.util.zip.deflater;
/**
* Esta clase implementa un filtro de flujo de salida para comprimir datos en
* El formato de compresión "desinflar".
* Tipos de filtros de compresión, como GzipoutputStream.
*
* @See Deflater
* @version 1.36, 13/03/06
* @author David Connelly
*/
público
clase DeFlAteOutputStream extiende FilterOutputStream {
/**
* Compresor para esta transmisión.
*/
Deflatador protegido def;
/**
* Buffer de salida para escribir datos comprimidos.
*/
byte protegido [] buf;
/**
* Indica que la corriente ha sido cerrada.
*/
booleano privado cerrado = falso;
/**
* Crea una nueva transmisión de salida con el compresor especificado y
* Tamaño del búfer.
* @param sale de la transmisión de salida
* @param Def el compresor ("Deflater")
* @param tamaño del tamaño del búfer de salida
* @Exception ilegalargumentException si el tamaño es <= 0
*/
public DeFlAterOutputStream (OutputStream Out, DeFlater Def, Int Size) {
super (fuera);
if (out == null || def == null) {
tirar nueva nullpointerException ();
} else if (size <= 0) {
tirar nueva ilegalArgumentException ("tamaño del amortiguador <= 0");
}
this.def = def;
buf = nuevo byte [tamaño];
}
/**
* Crea una nueva transmisión de salida con el compresor especificado y
* Un tamaño de búfer predeterminado.
* @param sale de la transmisión de salida
* @param Def el compresor ("Deflater")
*/
public DeFlAterOutputStream (OutputStream Out, DeFlater Def) {
esto (fuera, def, 512);
}
Boolean usaDefaultDeflater = false;
/**
* Crea una nueva transmisión de salida con un compresor predeterminado y un tamaño de búfer.
* @param sale de la transmisión de salida
*/
public DeFLATEROUTPUTStream (OutputStream Out) {
esto (fuera, nuevo deflater ());
usaDefaultdefLater = true;
}
/**
* Escribe un byte en la secuencia de salida comprimida.
* Bloquee hasta que se pueda escribir el byte.
* @param b el byte a escribir
* @Exception ioException si se ha producido un error de E/S
*/
Public void Write (int b) lanza ioexception {
byte [] buf = new Byte [1];
buf [0] = (byte) (b & 0xff);
escribir (buf, 0, 1);
}
/**
* Escribe una matriz de bytes en la transmisión de salida comprimida.
* El método bloqueará hasta que se escriban todos los bytes.
* @param b Los datos a escribir
* @param fuera de la compensación de inicio de los datos
* @param len la longitud de los datos
* @Exception ioException si se ha producido un error de E/S
*/
Public void Write (byte [] b, int off, int len) lanza ioexception {
if (def.finished ()) {
tirar nueva IOException ("Escribir más allá del final de la transmisión");
}
if ((Off | Len | (Off + Len) | (B.Length - (OFF + LEN))) <0) {
tirar nuevo índiceuTOUTOFBoundsexception ();
} else if (len == 0) {
devolver;
}
if (! def.finished ()) {
// Desintear no más que bytes de zancada a la vez.
// Copia en exceso en DeFlateBytes (ver DeFlater.c)
int stride = buf.length;
para (int i = 0; i <len; i+= stride) {
def.setInput (b, OFF + I, Math.min (Stride, Len - I));
while (! def.needsinput ()) {
desinflar();
}
}
}
}
/**
* Termina la redacción de datos comprimidos en la transmisión de salida sin cerrar
* El flujo subyacente.
* En sucesión a la misma secuencia de salida.
* @Exception ioException si se ha producido un error de E/S
*/
public void fink () lanza ioexception {
if (! def.finished ()) {
def.finish ();
while (! def.finished ()) {
desinflar();
}
}
}
/**
* Escribe datos comprimidos restantes en la secuencia de salida y cierra el
* Corriente subyacente.
* @Exception ioException si se ha producido un error de E/S
*/
public void Close () lanza ioexception {
if (! cerrado) {
finalizar();
if (usaDefaultDeflater)
defender();
out.close ();
cerrado = verdadero;
}
}
/**
* Escribe el siguiente bloque de datos comprimidos en la secuencia de salida.
* @throws ioexception si se ha producido un error de E/S
*/
vacío protegido deflate () lanza ioexception {
int len = def.deflate (buf, 0, buf.length);
if (len> 0) {
out.write (buf, 0, len);
}
}
}