Se você usar o kit de ferramentas de compactação que vem com Java para implementar a função de descomprimir arquivos para a pasta especificada, porque o zip fornecido pelo JDK só pode ser processado no formato UTF-8, e o nome do arquivo no sistema Windows é codificado em GBK, Portanto, se for descompactador de um pacote ZIP que contém o nome do arquivo chinês e relatará uma exceção ilegal de parâmetros. Java e ZipOutputStream.java.
Como o J2SE 1.4, o compilador Java não suporta mais aulas ou interfaces para nomes de pacotes sem nome; portanto, no projeto Java que você cria, você deve criar um novo pacote que você definir. do nome de domínio escolar +nome de rede, como cn.edu.xidian.crytoll.
Crie uma nova classe DeflaterOutputStream no pacote, o código é o seguinte:
DeflateroututputStream.java:
A cópia do código é a seguinte:
pacote cn.edu.xdian.crytoll;
importar java.io.FilterOutputStream;
importar java.io.ioException;
importar java.io.OutputStream;
importar java.util.zip.deflater;
/**
* Esta classe implementa um filtro de fluxo de saída para compactar dados em
* O formato de compressão "deflate".
* Tipos de filtros de compressão, como GzipOutputStream.
*
* @See Deflater
* @Version 1.36, 13/03/06
* @Author David Connelly
*/
público
classe DeflaterOutputStream estende FilterOutputStream {
/**
* Compressor para este fluxo.
*/
deflater de deflater protegido;
/**
* Buffer de saída para escrever dados compactados.
*/
byte protegido [] buf;
/**
* Indica que o fluxo foi fechado.
*/
Privado booleano fechado = false;
/**
* Cria um novo fluxo de saída com o compressor especificado e
* Tamanho do buffer.
* @param fora do fluxo de saída
* @param def o compressor ("deflater")
* @param tamanho do tamanho do buffer de saída
* @Exception ilegalargumentException se o tamanho é <= 0
*/
Public DeflaterOutputStream (OutputStream Out, Deflater Def, Int Size) {
super (fora);
if (out == null || def == null) {
lançar novo nullPointerException ();
} else if (size <= 0) {
lançar novas ilegalargumentException ("tamanho do buffer <= 0");
}
this.def = def
BUF = novo byte [tamanho];
}
/**
* Cria um novo fluxo de saída com o compressor especificado e
* Um tamanho de buffer padrão.
* @param fora do fluxo de saída
* @param def o compressor ("deflater")
*/
Public DeflaterOutputStream (OutputStream Out, Deflater Def) {
Isso (fora, def, 512);
}
boolean usaDefaultDeflater = false;
/**
* Cria um novo fluxo de saída com um tamanho de compressor e buffer padrão.
* @param fora do fluxo de saída
*/
Public DeflateroututputStream (OutputStream Out) {
Isso (fora, novo deflater ());
usaDefaultDeflater = true;
}
/**
* Grava um byte no fluxo de saída compactado
* Block até que o byte possa ser escrito.
* @param b o byte a ser escrito
* @Exception IoException Se ocorreu um erro de E/S
*/
public void write (int b) lança ioexception {
byte [] buf = novo byte [1];
BUF [0] = (byte) (b & 0xff);
escreva (buf, 0, 1);
}
/**
* Grava uma matriz de bytes no fluxo de saída compactado
* O método bloqueará até que todos os bytes sejam escritos.
* @param b Os dados a serem escritos
* @param off the start offset dos dados
* @param len o comprimento dos dados
* @Exception IoException Se ocorreu um erro de E/S
*/
public void Write (byte [] b, int off, int len) lança ioexception {
if (def.finished ()) {
lançar uma nova ioexception ("Escreva além do final do fluxo");
}
if ((off | len | (off + len) | (B.Length - (OFF + LEN))) <0) {
lançar novo indexOutOfBoundSexception ();
} else if (len == 0) {
retornar;
}
if (! def.finished ()) {
// Defllando não mais do que bytes de passo por vez
// O excesso de cópia em DeflateBytes (ver Deflater.c)
int stride = buf.length;
for (int i = 0; i <len; i+= stride) {
def.setInput (b, off + i, math.min (stride, len - i));
while (! Def.NeedsInput ()) {
deflate ();
}
}
}
}
/**
* Termina de escrever dados compactados no fluxo de saída sem fechar
* O fluxo subjacente.
* Em sucessão ao mesmo fluxo de saída.
* @Exception IoException Se ocorreu um erro de E/S
*/
public void acabamento () lança ioexception {
if (! def.finished ()) {
def.finish ();
while (! Def.Finished ()) {
deflate ();
}
}
}
/**
* Escreve dados comprimidos restantes no fluxo de saída e fecha o
* fluxo subjacente.
* @Exception IoException Se ocorreu um erro de E/S
*/
public void Close () lança ioexception {
if (! fechado) {
terminar();
if (usaDefaultDeflater)
defender();
out.Close ();
fechado = true;
}
}
/**
* Grava o próximo bloco de dados compactados no fluxo de saída.
* @Throws IoException se ocorreu um erro de E/S
*/
voce protegido deflate () lança ioexception {
int len = def.deflate (buf, 0, buf.length);
if (len> 0) {
out.write (buf, 0, len);
}
}
}