Java压缩与解压缩问题

Posted 2023-04-14

private void zipFile(File target)
if(source !=null)
try
label1.setText("正在压缩文件："+target.getPath()+"...");
FileOutputStream f = new FileOutputStream(target);
ZipOutputStream out = new ZipOutputStream(new DataOutputStream(f));
DataInputStream in = new DataInputStream(new FileInputStream(source));
out.putNextEntry(new ZipEntry(source.getPath()));
int c;
while((c = in.read()) != -1)
out.write(c);
in.close();
out.close();
label1.setText("文件压缩成功："+target.getPath());
catch(Exception e)
label1.setText("文件压缩失败："+target.getPath());


else
label1.setText("请先选择一个需要压缩的文件");


这是压缩的 谁能写出这个程序的具体流程 我要画流程图

public void loadZipFile(String name)
try
ZipInputStream zin = new ZipInputStream(new
FileInputStream(zipname));
ZipEntry entry;
fileText.setText("");
while ((entry = zin.getNextEntry()) != null)
if (entry.getName().equals(name))
BufferedReader in = new BufferedReader(new
InputStreamReader(zin));
String s;
while ((s = in.readLine()) != null)
fileText.append(s + "\n");

zin.closeEntry();

zin.close();

catch(IOException e)

这是接压缩的

参考技术A /**
*类名：zipFileRelease
*说明：一个zip文件解压类
*介绍：主要的zip文件释放方法releaseHandle()
* 用ZipInputStream类和ZipEntry类将zip文件的入口清单列举出来，然后
* 根据用户提供的输出路径和zip文件的入口进行组合通过DataOutputStream
* 和File类进行文件的创建和目录的创建，创建文件时的文件数据是通过
* ZipInputStream类、ZipEntry类、InputStream类之间的套嵌组合获得的。
*注意：如果zip文件中包含中文路径程序将会抛出异常
*日期：2005-7-1
*作者：Pcera
*/

import java.io.*;
import java.util.*;
import java.util.zip.*;

class zipFileRelease

private String inFilePath;
private String releaseFilePath;
private String[] FileNameArray; //存放文件名称的数组
private ZipEntry entry;
//
private FileInputStream fileDataIn;
private FileOutputStream fileDataOut;
private ZipInputStream zipInFile;
private DataOutputStream writeData;
private DataInputStream readData;
//
private int zipFileCount = 0; //zip文件中的文件总数
private int zipPathCount = 0; //zip文件中的路径总数

/**
*初始化函数
*初始化zip文件流、输出文件流以及其他变量的初始化
*/
public zipFileRelease(String inpath,String releasepath)
inFilePath = inpath;
releaseFilePath = releasepath;


/**
*初始化读取文件流函数
*参数：FileInputStream类
*返回值：初始化成功返回0，否则返回-1
*/
protected long initInStream(ZipInputStream zipFileA)
try
readData = new DataInputStream(zipFileA);
return 0;
catch(Exception e)
e.printStackTrace();
return -1;



/**
*测试文件路径
*参数：zip文件的路径和要释放的位置
*返回值：是两位整数，两位数中的十位代表输入路径和输出路径(1输入、2输出)
* 各位数是代表绝对路径还是相对路径(1绝对、0相对)
* 返回-1表示路径无效

protected long checkPath(String inPath,String outPath)
File infile = new File(inPath);
File infile = new File(outPath);


*/

/**
*初始化输出文件流
*参数：File类
*返回值：初始化成功返回0，否则返回-1
*/
protected long initOutStream(String outFileA)
try
fileDataOut = new FileOutputStream(outFileA);
writeData = new DataOutputStream(fileDataOut);
return 0;
catch(IOException e)
e.printStackTrace();
return -1;



/**
*测试文件是否存在方法
*参数：File类
*返回值：如果文件存在返回文件大小，否则返回-1
*/
public long checkFile(File inFileA)
if (inFileA.exists())
return 0;
else
return -1;



/**
*判断文件是否可以读取方法
*参数：File类
*返回值：如果可以读取返回0，否则返回-1
*/
public long checkOpen(File inFileA)
if(inFileA.canRead())
return inFileA.length();
else
return -1;



/**
*获得zip文件中的文件夹和文件总数
*参数：File类
*返回值：如果正常获得则返回总数，否则返回-1
*/
public long getFilFoldCount(String infileA)
try
int fileCount = 0;
zipInFile = new ZipInputStream(new FileInputStream(infileA));
while ((entry = zipInFile.getNextEntry()) != null)
if (entry.isDirectory())
zipPathCount++;
else
zipFileCount++;

fileCount++;

return fileCount;
catch(IOException e)
e.printStackTrace();
return -1;



/**
*读取zip文件清单函数
*参数：File类
*返回值：文件清单数组
*/
public String[] getFileList(String infileA)
try
ZipInputStream AzipInFile = new ZipInputStream(new FileInputStream(infileA));
//创建数组对象
FileNameArray = new String[(int)getFilFoldCount(infileA)];

//将文件名清单传入数组
int i = 0;
while ((entry = AzipInFile.getNextEntry()) != null)
FileNameArray[i++] = entry.getName();

return FileNameArray;
catch(IOException e)
e.printStackTrace();
return null;



/**
*创建文件函数
*参数：File类
*返回值:如果创建成功返回0，否则返回-1
*/
public long writeFile(String outFileA,byte[] dataByte)
try
if (initOutStream(outFileA) == 0)
writeData.write(dataByte);
fileDataOut.close();
return 0;
else
fileDataOut.close();
return -1;

catch(IOException e)
e.printStackTrace();
return -1;



/**
*读取文件内容函数
*参数：File类
*返回值:如果读取成功则返回读取数据的字节数组，如果失败则返回空值
*/
protected byte[] readFile(ZipEntry entryA,ZipInputStream zipFileA)
try
long entryFilelen;
if (initInStream(zipFileA) == 0)
if ((entryFilelen = entryA.getSize()) >= 0)
byte[] entryFileData = new byte[(int)entryFilelen];
readData.readFully(entryFileData,0,(int)entryFilelen);
return entryFileData;
else
return null;

else
return null;

catch(IOException e)
e.printStackTrace();
return null;



/**
*创建目录函数
*参数：要创建目录的路径
*返回值：如果创建成功则返回0，否则返回-1
*/
public long createFolder(String dir)
File file = new File(dir);
if (file.mkdirs())
return 0;
else
return -1;



/**
*删除文件
*参数：要删除的文件
*返回值：如果删除成功则返回0，要删除的文件不存在返回-2
* 如果要删除的是个路径则返回-3，删除失败则返回-1
*/
public long deleteFile(String Apath) throws SecurityException
File file = new File(Apath.trim());
//文件或路径不存在
if (!file.exists())
return -2;

//要删除的是个路径
if (!file.isFile())
return -3;

//删除
if (file.delete())
return 0;
else
return -1;



/**
*删除目录
*参数：要删除的目录
*返回值：如果删除成功则返回0，删除失败则返回-1
*/
public long deleteFolder(String Apath)
File file = new File(Apath);
//删除
if (file.delete())
return 0;
else
return -1;



/**
*判断所要解压的路径是否存在同名文件
*参数：解压路径
*返回值：如果存在同名文件返回-1，否则返回0
*/
public long checkPathExists(String AreleasePath)
File file = new File(AreleasePath);
if (!file.exists())
return 0;
else
return -1;



/**
*删除zip中的文件
*参数：文件清单数组，释放路径
*返回值：如果删除成功返回0,否则返回-1
*/
protected long deleteReleaseZipFile(String[] listFilePath,String releasePath)
long arrayLen,flagReturn;
int k = 0;
String tempPath;
//存放zip文件清单的路径
String[] pathArray = new String[zipPathCount];
//删除文件
arrayLen = listFilePath.length;
for(int i=0;i<(int)arrayLen;i++)
tempPath = releasePath.replace('\\','/') + listFilePath[i];
flagReturn = deleteFile(tempPath);
if (flagReturn == -2)
//什么都不作
else if (flagReturn == -3)
pathArray[k++] = tempPath;
else if (flagReturn == -1)
return -1;


//删除路径
for(k = k - 1;k>=0;k--)
flagReturn = deleteFolder(pathArray[k]);
if (flagReturn == -1) return -1;

return 0;


/**
*获得zip文件的最上层的文件夹名称
*参数：zip文件路径
*返回值：文件夹名称，如果失败则返回null
*/
public String getZipRoot(String infileA)
String rootName;
try
FileInputStream tempfile = new FileInputStream(infileA);
ZipInputStream AzipInFile = new ZipInputStream(tempfile);
ZipEntry Aentry;
Aentry = AzipInFile.getNextEntry();
rootName = Aentry.getName();
tempfile.close();
AzipInFile.close();
return rootName;
catch(IOException e)
e.printStackTrace();
return null;



/**
*释放流，释放占用资源
*/
protected void closeStream() throws Exception
fileDataIn.close();
fileDataOut.close();
zipInFile.close();
writeData.flush();


/**
*解压函数
*对用户的zip文件路径和解压路径进行判断，是否存在和打开
*在输入解压路径时如果输入"/"则在和zip文件存放的统计目录下进行解压
*返回值：0表示释放成功
* -1 表示您所要解压的文件不存在、
* -2表示您所要解压的文件不能被打开、
* -3您所要释放的路径不存在、
* -4您所创建文件目录失败、
* -5写入文件失败、
* -6表示所要释放的文件已经存在、
* -50表示文件读取异常
*/
public long releaseHandle() throws Exception
File inFile = new File(inFilePath);
File outFile = new File(releaseFilePath);
String tempFile;
String zipPath;
String zipRootPath;
String tempPathParent; //存放释放路径
byte[] zipEntryFileData;

//作有效性判断
if (checkFile(inFile) == -1)
return -1;
if (checkOpen(inFile) == -1)
return -2;
//不是解压再当前目录下时对路径作有效性检验
if (!releaseFilePath.equals("/"))
//解压在用户指定目录下
if (checkFile(outFile) == -1)
return -3;

//获得标准释放路径
if (!releaseFilePath.equals("/"))
tempPathParent = releaseFilePath.replace('\\','/')+ "/";
else
tempPathParent = inFile.getParent().replace('\\','/')+ "/";

//获得zip文件中的入口清单
FileNameArray = getFileList(inFilePath);
//获得zip文件的最上层目录
zipRootPath = getZipRoot(inFilePath);
//
fileDataIn = new FileInputStream(inFilePath);
zipInFile = new ZipInputStream(fileDataIn);
//判断是否已经存在要释放的文件夹
if (zipRootPath.lastIndexOf("/") > 0 )
if (checkPathExists(tempPathParent +
zipRootPath.substring(0,zipRootPath.lastIndexOf("/"))) == -1)
return -6;

else
if (checkPathExists(tempPathParent + zipRootPath) == -1)
return -6;



//
try
//创建文件夹和文件
int i = 0;
while ((entry = zipInFile.getNextEntry()) != null)
if (entry.isDirectory())
//创建目录
zipPath = tempPathParent + FileNameArray[i];
zipPath = zipPath.substring(0,zipPath.lastIndexOf("/"));
if (createFolder(zipPath) == -1)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
return -4;


else
//读取文件数据
zipEntryFileData = readFile(entry,zipInFile);
//向文件写数据
tempFile = tempPathParent + FileNameArray[i];
//写入文件
if (writeFile(tempFile,zipEntryFileData) == -1)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
return -5;


i++;

//释放资源
closeStream();
return 0;
catch(Exception e)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
e.printStackTrace();
return -50;


/**
*演示函数
*根据用户输入的路径对文件进行解压
*/
public static void main(String args[]) throws Exception

long flag; //返回标志
String inPath,releasePath;

//获得用户输入信息
BufferedReader userInput = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("请输入zip文件路径：");
inPath = userInput.readLine();
System.out.println("请输入保存路径：");
releasePath = userInput.readLine();
userInput.close();

//执行解压缩
zipFileRelease pceraZip = new zipFileRelease(inPath,releasePath);
flag = pceraZip.releaseHandle();

//出错信息打印
if (flag == 0) System.out.println("释放成功！！！");
if (flag == -1) System.out.println("您所要解压的文件不存在！");
if (flag == -2) System.out.println("您所要解压的文件不能被打开！");
if (flag == -3) System.out.println("您所要释放的路径不存在！");
if (flag == -4) System.out.println("您所创建文件目录失败！");
if (flag == -5) System.out.println("写入文件失败！");
if (flag == -6) System.out.println("文件已经存在！");
if (flag == -50) System.out.println("文件读取异常！");

java-a实现压缩与解压缩（zipgzip）

zip扮演着归档和压缩两个角色；gzip并不将文件归档，仅只是对单个文件进行压缩，所以，在UNIX平台上，命令tar通常用来创建一个档案文件，然后命令gzip来将档案文件压缩。

Java I/O类库还收录了一些能读写压缩格式流的类。要想提供压缩功能，只要把它们包在已有的I/O类的外面就行了。这些类不是Reader和Writer，而是InputStream和OutStreamput的子类。这是因为压缩算法是针对byte而不是字符的。

需要注意的是：java自带的工具类在windows压缩处理编码无法处理中文，所以不建议使用jre

相关类与接口：

Checksum 接口：被类Adler32和CRC32实现的接口
Adler32 ：使用Alder32算法来计算Checksum数目
CRC32 ：使用CRC32算法来计算Checksum数目


CheckedInputStream ：InputStream派生类，可得到输入流的校验和Checksum，用于校验数据的完整性
CheckedOutputStream ：OutputStream派生类，可得到输出流的校验和Checksum， 用于校验数据的完整性


DeflaterOutputStream ：压缩类的基类。 
ZipOutputStream ：DeflaterOutputStream的一个子类，把数据压缩成Zip文件格式。
GZIPOutputStream ：DeflaterOutputStream的一个子类，把数据压缩成GZip文件格式


InflaterInputStream ：解压缩类的基类
ZipInputStream ：InflaterInputStream的一个子类，能解压缩Zip格式的数据
GZIPInputStream ：InflaterInputStream的一个子类，能解压缩Zip格式的数据


ZipEntry 类：表示 ZIP 文件条目
ZipFile 类：此类用于从 ZIP 文件读取条目

 

压缩类的用法非常简单；只要用GZIPOutputStream 或ZipOutputStream把输出流包起来，再用GZIPInputStream 或ZipInputStream把输入流包起来就行了。剩下的都是些普通的I/O操作。

测试

package com.jre.util.zip;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import com.jre.io.UtilsIoJre;

/**
 * zip文件处理(压缩处理时通过windows系统压缩的由于编码不是utf8的所以将导致中文抛出异常的情况)
 * @author huage
 *
 */
public class UtilsZipJre {

    public static void main(String[] args) {
        zipFileExtract("C:\\Users\\huage\\Desktop\\test\\111\\111.zip","C:\\Users\\huage\\Desktop\\test\\test");
        //zipDecompressingExtract("C:\\Users\\huage\\Desktop\\test\\111\\111.zip","C:\\Users\\huage\\Desktop\\test\\test");
        //zipCompressingExtract("C:\\Users\\huage\\Desktop\\test\\111\\test.zip",new File("C:\\Users\\huage\\Desktop\\test\\test"));

    }
    
    /**
     * 解压
     * @param path
     * @param pathExtract
     */
    public static void zipFileExtract(String path, String pathExtract){
        ZipFile zipfile = null;
        try {
            zipfile = new ZipFile(path);
            Enumeration<ZipEntry> entries = (Enumeration<ZipEntry>)zipfile.entries();
            if( entries!=null ){
                ZipEntry entry ;
                File file;  
                BufferedInputStream bis = null;  
                while( entries.hasMoreElements()){  
                    entry = entries.nextElement();
                    if(entry.isDirectory())continue; 
                    file=new File(pathExtract,entry.getName());  
                    if(!file.exists()){  
                        (new File(file.getParent())).mkdirs();  
                    } 
                    UtilsIoJre.converWriteIO(bis, file);
                    //System.out.println(fout+"解压成功");    
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            UtilsIoJre.closeIO(zipfile);
        }
        
    }
    

    /**
     * zip解压(本地)（官方自带zip解压无法处理中文）
     * 
     * @param path
     *            :zip文件地址
     * @param pathExtract
     *            ：解压地址
     */
    public static void zipDecompressingExtract(String path, String pathExtract) {
        ZipInputStream zipinput = null;
        BufferedInputStream bininput = null;
        try {
            zipinput = new ZipInputStream(new FileInputStream(path));
            bininput = new BufferedInputStream(zipinput);

            
            ZipEntry entry ;
            File fout = null;
            while ((entry = zipinput.getNextEntry()) != null) {
                if(entry.isDirectory())continue; 
                fout=new File(pathExtract,entry.getName());  
                if(!fout.exists()){  
                    (new File(fout.getParent())).mkdirs();  
                } 
                UtilsIoJre.converWriteIO(bininput, fout);
                //System.out.println(fout+"解压成功");    
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            UtilsIoJre.closeIO(bininput,zipinput);
        }
        System.out.println("解压完成");
    }

    /**
     * zip压缩(本地)
     * 
     * @param zipFileName
     * @param inputFile
     * @throws Exception
     */
    public static void zipCompressingExtract(String zipFileName, File inputFile) {
        ZipOutputStream out = null;
        BufferedOutputStream bo = null;
        try {
            out = new ZipOutputStream(new FileOutputStream(zipFileName));
            bo = new BufferedOutputStream(out);
            zipCompressing(out, inputFile, bo);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            UtilsIoJre.closeIO(bo,out);
        }
        System.out.println("压缩完成");
    }

    /**
     * zip压缩
     * 
     * @param out
     * @param file
     * @param base
     * @param bo
     * @throws Exception
     */
    private static void zipCompressing(ZipOutputStream out, File file, BufferedOutputStream bo) throws Exception {
        if (file.isDirectory()) {
            File[] fl = file.listFiles();
            if (fl.length == 0) {
                out.putNextEntry(new ZipEntry(file.getName()));
            }
            for (int i = 0; i < fl.length; i++) {
                zipCompressing(out, fl[i], bo);
            }
        } else {
            out.putNextEntry(new ZipEntry(file.getName() ));
            UtilsIoJre.converReadIO(bo, file);
        }
    }
}


package com.jre.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * io流处理
 * @author huage
 *
 */
public class UtilsIoJre {

    /**
     * 将file写入BufferedOutputStream中
     * @param bo
     * @param file
     * @throws Exception
     */
    public static void converReadIO(BufferedOutputStream bo,File file) throws Exception{
        FileInputStream in = new FileInputStream(file);
        BufferedInputStream bi = new BufferedInputStream(in);
        int b;
        while ((b = in.read()) != -1) {
            bo.write(b);
        }
        closeIO(bi,in);
        bo.flush();//清空缓存
    }
    
    /**
     * 将BufferedInputStream写入file中
     * @param bo
     * @param file
     * @throws Exception
     */
    public static void converWriteIO(BufferedInputStream bininput,File file) throws Exception{
        FileOutputStream out = new FileOutputStream(file);
        BufferedOutputStream bout = new BufferedOutputStream(out);
        int b;
        while ((b = bininput.read()) != -1) {
            bout.write(b);
        }
        closeIO(bout,out);
        bout.flush();//清空缓存
    }
    
    
    /**
     * 关闭io
     * @param cl
     */
    public static void closeIO(AutoCloseable... cl){
        if( cl == null || cl.length == 0 )return;
        for (AutoCloseable c : cl) {
            try {
                c.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}