java解压与压缩代码 Java压缩

关于Java的解压缩的代码？

package com.javatest.techzero.gui;  

创新互联建站专业为企业提供商洛网站建设、商洛做网站、商洛网站设计、商洛网站制作等企业网站建设、网页设计与制作、商洛企业网站模板建站服务，十余年商洛做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipInputStream; 

public class ZipFileDemo {

@SuppressWarnings("resource")

public static void main(String args[]) throws Exception {

File file = new File("d:" + File.separator + "test.zip");

File outFile = null;

ZipFile zipFile = new ZipFile(file);

ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));

ZipEntry entry = null;

InputStream input = null;

OutputStream out = null;

while ((entry = zipInput.getNextEntry()) != null) {

System.out.println("开始解压缩" + entry.getName() + "文件。。。");

outFile = new File("d:" + File.separator + entry.getName());

if (!outFile.getParentFile().exists()) {

outFile.getParentFile().mkdir();

}

if (!outFile.exists()) {

outFile.createNewFile();

}

input = zipFile.getInputStream(entry);

out = new FileOutputStream(outFile);

int temp = 0;

while ((temp = input.read()) != -1) {

SPAN style="WHITE-SPACE: pre" /SPAN//System.out.println(temp);

out.write(temp);

}

input.close();

out.close();

}

System.out.println("Done!");

}

}

仅供参考

怎样用java快速实现zip文件的压缩解压缩

package zip;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.util.Enumeration;

import java.util.zip.CRC32;

import java.util.zip.CheckedOutputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

import org.apache.commons.lang3.StringUtils;

public class ZipUtil {

/**

 * 递归压缩文件夹

 * @param srcRootDir 压缩文件夹根目录的子路径

 * @param file 当前递归压缩的文件或目录对象

 * @param zos 压缩文件存储对象

 * @throws Exception

 */

private static void zip(String srcRootDir, File file, ZipOutputStream zos) throws Exception

{

if (file == null) 

{

return;

}

//如果是文件，则直接压缩该文件

if (file.isFile())

{

int count, bufferLen = 1024;

byte data[] = new byte[bufferLen];

//获取文件相对于压缩文件夹根目录的子路径

String subPath = file.getAbsolutePath();

int index = subPath.indexOf(srcRootDir);

if (index != -1) 

{

subPath = subPath.substring(srcRootDir.length() + File.separator.length());

}

ZipEntry entry = new ZipEntry(subPath);

zos.putNextEntry(entry);

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

while ((count = bis.read(data, 0, bufferLen)) != -1) 

{

zos.write(data, 0, count);

}

bis.close();

zos.closeEntry();

}

//如果是目录，则压缩整个目录

else 

{

//压缩目录中的文件或子目录

File[] childFileList = file.listFiles();

for (int n=0; nchildFileList.length; n++)

{

childFileList[n].getAbsolutePath().indexOf(file.getAbsolutePath());

zip(srcRootDir, childFileList[n], zos);

}

}

}

/**

 * 对文件或文件目录进行压缩

 * @param srcPath 要压缩的源文件路径。如果压缩一个文件，则为该文件的全路径；如果压缩一个目录，则为该目录的顶层目录路径

 * @param zipPath 压缩文件保存的路径。注意：zipPath不能是srcPath路径下的子文件夹

 * @param zipFileName 压缩文件名

 * @throws Exception

 */

public static void zip(String srcPath, String zipPath, String zipFileName) throws Exception

{

if (StringUtils.isEmpty(srcPath) || StringUtils.isEmpty(zipPath) || StringUtils.isEmpty(zipFileName))

{

throw new ParameterException(ICommonResultCode.PARAMETER_IS_NULL);

}

CheckedOutputStream cos = null;

ZipOutputStream zos = null;

try

{

File srcFile = new File(srcPath);

//判断压缩文件保存的路径是否为源文件路径的子文件夹，如果是，则抛出异常（防止无限递归压缩的发生）

if (srcFile.isDirectory()  zipPath.indexOf(srcPath)!=-1) 

{

throw new ParameterException(ICommonResultCode.INVALID_PARAMETER, "zipPath must not be the child directory of srcPath.");

}

//判断压缩文件保存的路径是否存在，如果不存在，则创建目录

File zipDir = new File(zipPath);

if (!zipDir.exists() || !zipDir.isDirectory())

{

zipDir.mkdirs();

}

//创建压缩文件保存的文件对象

String zipFilePath = zipPath + File.separator + zipFileName;

File zipFile = new File(zipFilePath);

if (zipFile.exists())

{

//检测文件是否允许删除，如果不允许删除，将会抛出SecurityException

SecurityManager securityManager = new SecurityManager();

securityManager.checkDelete(zipFilePath);

//删除已存在的目标文件

zipFile.delete();

}

cos = new CheckedOutputStream(new FileOutputStream(zipFile), new CRC32());

zos = new ZipOutputStream(cos);

//如果只是压缩一个文件，则需要截取该文件的父目录

String srcRootDir = srcPath;

if (srcFile.isFile())

{

int index = srcPath.lastIndexOf(File.separator);

if (index != -1)

{

srcRootDir = srcPath.substring(0, index);

}

}

//调用递归压缩方法进行目录或文件压缩

zip(srcRootDir, srcFile, zos);

zos.flush();

}

catch (Exception e) 

{

throw e;

}

finally 

{

try

{

if (zos != null)

{

zos.close();

}

}

catch (Exception e)

{

e.printStackTrace();

}

}

}

/**

 * 解压缩zip包

 * @param zipFilePath zip文件的全路径

 * @param unzipFilePath 解压后的文件保存的路径

 * @param includeZipFileName 解压后的文件保存的路径是否包含压缩文件的文件名。true-包含；false-不包含

 */

@SuppressWarnings("unchecked")

public static void unzip(String zipFilePath, String unzipFilePath, boolean includeZipFileName) throws Exception

{

if (StringUtils.isEmpty(zipFilePath) || StringUtils.isEmpty(unzipFilePath))

{

throw new ParameterException(ICommonResultCode.PARAMETER_IS_NULL);

}

File zipFile = new File(zipFilePath);

//如果解压后的文件保存路径包含压缩文件的文件名，则追加该文件名到解压路径

if (includeZipFileName)

{

String fileName = zipFile.getName();

if (StringUtils.isNotEmpty(fileName))

{

fileName = fileName.substring(0, fileName.lastIndexOf("."));

}

unzipFilePath = unzipFilePath + File.separator + fileName;

}

//创建解压缩文件保存的路径

File unzipFileDir = new File(unzipFilePath);

if (!unzipFileDir.exists() || !unzipFileDir.isDirectory())

{

unzipFileDir.mkdirs();

}

//开始解压

ZipEntry entry = null;

String entryFilePath = null, entryDirPath = null;

File entryFile = null, entryDir = null;

int index = 0, count = 0, bufferSize = 1024;

byte[] buffer = new byte[bufferSize];

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

ZipFile zip = new ZipFile(zipFile);

EnumerationZipEntry entries = (EnumerationZipEntry)zip.entries();

//循环对压缩包里的每一个文件进行解压

while(entries.hasMoreElements())

{

entry = entries.nextElement();

//构建压缩包中一个文件解压后保存的文件全路径

entryFilePath = unzipFilePath + File.separator + entry.getName();

//构建解压后保存的文件夹路径

index = entryFilePath.lastIndexOf(File.separator);

if (index != -1)

{

entryDirPath = entryFilePath.substring(0, index);

}

else

{

entryDirPath = "";

}

entryDir = new File(entryDirPath);

//如果文件夹路径不存在，则创建文件夹

if (!entryDir.exists() || !entryDir.isDirectory())

{

entryDir.mkdirs();

}

//创建解压文件

entryFile = new File(entryFilePath);

if (entryFile.exists())

{

//检测文件是否允许删除，如果不允许删除，将会抛出SecurityException

SecurityManager securityManager = new SecurityManager();

securityManager.checkDelete(entryFilePath);

//删除已存在的目标文件

entryFile.delete();

}

//写入文件

bos = new BufferedOutputStream(new FileOutputStream(entryFile));

bis = new BufferedInputStream(zip.getInputStream(entry));

while ((count = bis.read(buffer, 0, bufferSize)) != -1)

{

bos.write(buffer, 0, count);

}

bos.flush();

bos.close();

}

}

public static void main(String[] args) 

{

String zipPath = "d:\\ziptest\\zipPath";

String dir = "d:\\ziptest\\rawfiles";

String zipFileName = "test.zip";

try

{

zip(dir, zipPath, zipFileName);

} 

catch (Exception e)

{

e.printStackTrace();

}

String zipFilePath = "D:\\ziptest\\zipPath\\test.zip";

String unzipFilePath = "D:\\ziptest\\zipPath";

try 

{

unzip(zipFilePath, unzipFilePath, true);

}

catch (Exception e)

{

e.printStackTrace();

}

}

}

Java压缩与解压缩问题

/**

*类名：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("文件读取异常！");

}

}

C# 中GZIP 压缩，求在JAVA中解压代码

byte[] buf = new byte[4096*2];

//建立字节数组输入流

ByteArrayInputStream i = new ByteArrayInputStream(buffer);

//建立gzip解压输入流

GZIPInputStream gzin = new GZIPInputStream(i);

int size = gzin.read(buf);

i.close();

gzin.close();

byte b[] = new byte[size];

System.arraycopy(buf,0,b,0,size);

return b;