Si vous utilisez la boîte à outils de compression qui est livrée avec Java pour implémenter la fonction de décompression des fichiers dans le dossier spécifié, car le zip fourni par JDK ne peut être traité que au format UTF-8, et le nom de fichier dans le système Windows est encodé dans GBK, Donc, s'il s'agit de décompresser un package zip contenant le nom de fichier chinois, et il rapportera une exception de paramètre illégal. Java et ZipOutputStream.java.
Depuis J2SE 1.4, le compilateur Java ne prend plus en charge les classes d'importation ou les interfaces pour les noms de packages sans nom, donc dans le projet Java que vous créez, vous devez créer un nouveau package que vous définissez vous-même. du nom de domaine scolaire + propre nom de réseau, tel que cn.edu.xidian.crytoll.
Créez une nouvelle classe DeflaterOutputStream dans le package, le code est le suivant:
DeflaterOutputStream.java:
La copie de code est la suivante:
package cn.edu.xdian.crytoll;
import java.io.filterOutputStream;
Importer java.io.ioException;
import java.io.outputStream;
import java.util.zip.deflater;
/ **
* Cette classe implémente un filtre de flux de sortie pour compresser les données dans
* Le format de compression "dégonflerait".
* Types de filtres de compression, tels que gzipOutputStream.
*
* @see Deflater
* @version 1.36, 13/03/06
* @author David Connelly
* /
publique
classe DeflaterOutputStream étend FilterOutputStream {
/ **
* Compresseur pour ce flux.
* /
Deflater protégé Def;
/ **
* Tampon de sortie pour écrire des données compressées.
* /
octet protégé [] buf;
/ **
* Indique que le flux a été fermé.
* /
Boolean privé fermé = false;
/ **
* Crée un nouveau flux de sortie avec le compresseur spécifié et
* Taille du tampon.
* @param sur le flux de sortie
* @param def le compresseur ("Deflater")
* Taille @param La taille du tampon de sortie
* @Exception illégalArgumentException si la taille est <= 0
* /
public DeflaterOutputStream (OutputStream Out, Deflater Def, int Size) {
super (out);
if (out == null || def == null) {
lancer un nouveau nullpointerException ();
} else if (size <= 0) {
Jetez un nouveau IllégalArgumentException ("Taille du tampon <= 0");
}
this.def = def;
buf = nouveau octet [taille];
}
/ **
* Crée un nouveau flux de sortie avec le compresseur spécifié et
* Une taille de tampon par défaut.
* @param sur le flux de sortie
* @param def le compresseur ("Deflater")
* /
public DeflaterOutputStream (OutputStream Out, Deflater Def) {
ceci (out, def, 512);
}
booléen usedefaultDeflater = false;
/ **
* Crée un nouveau flux de sortie avec un compresseur par défaut et une taille de tampon.
* @param sur le flux de sortie
* /
public DeflaterOutputStream (OutputStream out) {
Ceci (out, new Deflater ());
useDefaultDeflater = true;
}
/ **
* Écrit un octet au flux de sortie comprimé.
* Bloquer jusqu'à ce que l'octet puisse être écrit.
* @param b L'octet à écrire
* @Exception iOException si une erreur d'E / S s'est produite
* /
public void write (int b) lance ioexception {
octet [] buf = nouveau octet [1];
buf [0] = (byte) (b & 0xff);
écrire (buf, 0, 1);
}
/ **
* Écrit un tableau d'octets au flux de sortie comprimé.
* La méthode bloquera jusqu'à ce que tous les octets soient écrits.
* @param b les données à écrire
* @param hors du décalage de début des données
* @param len la longueur des données
* @Exception iOException si une erreur d'E / S s'est produite
* /
public void write (byte [] b, int off, int len) lève ioException {
if (def.finished ()) {
lancer une nouvelle ioException ("Écrire au-delà de la fin du flux");
}
if ((off | len | (off + len) | (b.length - (off + len))) <0) {
lancer une nouvelle indexoutofboundSexception ();
} else if (len == 0) {
retour;
}
if (! def.finished ()) {
// ne dégonfle pas plus que les octets de stride à la fois.
// Excès de copie dans DeflateBytes (voir Deflater.c)
int stride = buf.length;
pour (int i = 0; i <len; i + = stride) {
def.setInput (b, off + i, math.min (stride, len - i));
while (! def.needSInput ()) {
dégonfler();
}
}
}
}
/ **
* Termine la rédaction de données compressées au flux de sortie sans fermer
* Le flux sous-jacent. Utilisez cette méthode lors de l'application de plusieurs filtres
* successivement au même flux de sortie.
* @Exception iOException si une erreur d'E / S s'est produite
* /
public void Finish () lève IOException {
if (! def.finished ()) {
Def.finish ();
while (! def.finished ()) {
dégonfler();
}
}
}
/ **
* Écrit les données compressées restantes au flux de sortie et ferme le
* Stream sous-jacent.
* @Exception iOException si une erreur d'E / S s'est produite
* /
public void close () lève ioException {
if (! fermé) {
finition();
if (usedefaultdeflater)
défendre();
out.close ();
fermé = true;
}
}
/ **
* Écrit le bloc suivant de données compressées au flux de sortie.
* @throws ioexception si une erreur d'E / S s'est produite
* /
Protected void déglader () lève ioException {
int len = def.deflate (buf, 0, buf.length);
if (len> 0) {
out.write (buf, 0, len);
}
}
}