java壓縮解壓代碼

Ⅰ 關於java的解壓縮的代碼

packagecom.javatest.techzero.gui;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipFile;
importjava.util.zip.ZipInputStream;
publicclassZipFileDemo{
@SuppressWarnings("resource")
publicstaticvoidmain(Stringargs[])throwsException{
Filefile=newFile("d:"+File.separator+"test.zip");
FileoutFile=null;
ZipFilezipFile=newZipFile(file);
ZipInputStreamzipInput=newZipInputStream(newFileInputStream(file));
ZipEntryentry=null;
InputStreaminput=null;
OutputStreamout=null;
while((entry=zipInput.getNextEntry())!=null){
System.out.println("開始解壓縮"+entry.getName()+"文件。。。");
outFile=newFile("d:"+File.separator+entry.getName());
if(!outFile.getParentFile().exists()){
outFile.getParentFile().mkdir();
}
if(!outFile.exists()){
outFile.createNewFile();
}
input=zipFile.getInputStream(entry);
out=newFileOutputStream(outFile);
inttemp=0;
while((temp=input.read())!=-1){
<SPANstyle="WHITE-SPACE:pre"></SPAN>//System.out.println(temp);
out.write(temp);
}
input.close();
out.close();
}
System.out.println("Done!");
}
}

僅供參考

Ⅱ java壓縮文件用ZipInputStream無法解壓，下面是源代碼

我想代碼基本沒有錯，可以解壓zip文件
但你的輸入文件是rar。
rar和zip是完全不同的演算法。rar是商業壓縮格式，zip是公開格式。
java的預置庫目前無法直接解壓rar ，需要用第三方庫

Ⅲ java實現壓縮視頻文件，但是壓縮後並解壓，提示文件損壞，我該怎麼修改代碼

(1)網路傳輸狀況不好(如斷線過多，開的線程過多，伺服器人太多導致不能連接太多等)導致下載下來的文件損壞!
(2)站點提供的的RAR壓縮包本來就是損壞的(這個本站可以保證，所上傳的視頻及軟體等都經過好幾遍測試，絕對沒問題)。
(3)所使用的下載工具不夠完善，比如有的下載工具多開了幾個線程後，下載的收尾工作很慢，有些時候下載到99%時數據就不再傳輸了，一定要人工操作才能結束(先停止下載接著再開始)。筆者就碰到過好幾次這樣的情況。結果是文件下載下來以後解壓縮到快結束時CRC出錯。
解決方法：本站為防止這樣的事情發生，在每個壓縮包里又加了一個備份，防止因以上原因導致的下載後不能用，還得重新下載的問題，只要你下載下來的那個壓縮包里的備份是好的那就能把壓縮包里的文件恢復能用。
步驟一：雙擊打開需要解壓修復的壓縮包，選擇：工具——修復壓縮文件。
步驟二：出現下邊圖片的修復框，等待修復完成，關閉窗口及解壓縮窗口就可以了。
步驟三：這時你會發現你需要解壓的壓縮包旁邊多了一個壓縮包，名稱為：fixed.***（你下載的視頻名稱）.rar ，這個壓縮包就是修復後的解壓縮包，如果修復成功，解壓這個名稱為：fixed.***（你下載的視頻名稱）.rar 的壓縮包就可以了。
如果修復不成功，你再修復幾次看看，如果不行，只有再重新下載了

Ⅳ java如何直接解壓zip格式二進制流

Java代碼
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

class ZipTest {
// 壓縮
public static void zip(String zipFileName, String inputFile)
throws Exception {
File f = new File(inputFile);
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
zipFileName));
zip(out, f, f.getName());
System.out.println("zip done");
out.close();

Ⅳ 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.array(buf,0,b,0,size);
return b;

Ⅵ java中怎麼用cmd命令解壓zip文件

對於zip文件，java有自帶類庫java.util.zip；可是要想解壓rar文件只能靠第三方類庫，我試過兩個：com.github.junrar和de.innosystec.unrar，前者解壓時可能會出現crcError，後者pom配置時報錯；利用cmd命令調用winRAR進行解壓，無疑方便快捷很多。
調用cmd命令
public
static
boolean
exe(String
cmd)
{
Runtime
runtime
=
Runtime.getRuntime();try
{
Process
p
=
runtime.exec(cmd);
BufferedReader
reader
=
new
BufferedReader(new
InputStreamReader(p.getInputStream(),"GBK"));
String
line
=
reader.readLine();

while(line!=null)
{
logger.info(line);
line
=
reader.readLine();
}
reader.close();

if(p.waitFor()!=0)
{return
false;
}
}
catch
(IOException
e)
{

//
TODO
Auto-generated
catch
block
e.printStackTrace();
}
catch
(InterruptedException
e)
{

//
TODO
Auto-generated
catch
block
e.printStackTrace();
}return
true;
}
首先利用runtime.exec()執行指令，得到process，從process.getInputStream()中獲取回顯字元並列印，列印回顯時可能會出現中文亂碼，這個和操作系統編碼有關，我這里是GBK編碼，所以在new
inputstreamReader時加入了編碼參數」GBK「
命令行字元串
如果需要調用cmd命令，如cd等，可寫」cmd
c
cd
目錄」。對於直接調用exe執行，則可以寫成」exe文件絕對路徑
參數」，在命令行字元串中，含有空格的路徑或者字元串應該再加上引號，即」」exe文件絕對路徑」
」參數」「
winRAR調用
我這里安裝目錄是C:/Program
Files/WinRAR，將D：1.rar
解壓到D：,則寫成」」C:/Program
Files/WinRAR/unRar.exe」
x
-y
D:/1.rar
D:/」,x代表絕對路徑解壓，-y表示全部確定；壓縮的命令如下：「」C:/Program
Files/WinRAR/rar.exe」
a
-ep1
D:2.rar
D:源目錄」，a表示添加文件到壓縮文件，-ep1表示排除基本目錄，如D：winrar ar這個目錄，如果沒有-ep1那麼壓縮包中會出現winrar目錄路徑，而加了之後就只將當前目錄打包，只有rar目錄

Ⅶ java 以流的形式解壓帶密碼的zip

可以使用 Runtime 直接調用 winRar 的命令行命令來解壓縮
注意：
1、winRar命令使用，在dos下輸入 unrar 就可以看到全部的命令說明。該命令在winRar的安裝目錄下
2、winRar命令行命令的路徑問題，也就是path。要麼加入系統變數path中，要麼在winRar的安裝目錄下執行程序
以下是程序代碼，解壓 test.rar 到當前目錄下，密碼123

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class TestRunTime {

public static void main(String[] args) {
Runtime run = Runtime.getRuntime();
try {
Process p = run.exec("unrar e test.rar -p123");//執行解壓縮命令
BufferedInputStream in = new BufferedInputStream(p.getInputStream());
BufferedReader inBr = new BufferedReader(new InputStreamReader(in));
String lineStr;

while ((lineStr = inBr.readLine()) != null)
System.out.println(lineStr);
// 檢查命令是否執行失敗。
if (p.waitFor() != 0) {
if (p.exitValue() == 1)// p.exitValue()==0表示正常結束，1：非正常結束
System.err.println("命令執行失敗!");
}

} catch (Exception e) {
e.printStackTrace();
}

}

}

Ⅷ 如何用java代碼調用解壓工具去解壓.exe文件

再 windows下通過 cmd命令執行解壓縮沒問題，但是通過 java代碼去執行不能解壓是為什麼？我在開始運行中輸入命令： cmd/ c rar. exe x- y d:\\ auto. rar d:\\----上面命令可以解壓成功，但是通過下面 java代碼不能實現解壓縮功能，請指點。主要代碼： java. lang. Runtime. getRuntime(). exec(" cmd/ c rar. exe x- y d:\\ auto. rar d:\\");
再 windows下通過 cmd命令執行解壓縮沒問題，但是通過 java代碼去執行不能解壓是為什麼？我在開始運行中輸入命令： cmd/ c rar. exe x- y d:\\ auto. rar d:\\----上面命令可以解壓成功，但是通過下面 java代碼不能實現解壓縮功能，請指點。主要代碼： java. lang. Runtime. getRuntime(). exec(" cmd/ c rar. exe x- y d:\\ auto. rar d:\\");

Ⅸ 用java小應用程序實現文件壓縮、解壓縮

40.ZIP壓縮文件
/*
import java.io.*;
import java.util.zip.*;
*/
//創建文件輸入流對象
FileInputStream fis=new FileInputStream(%%1);
//創建文件輸出流對象
FileOutputStream fos=new FileOutputStream(%%2);
//創建ZIP數據輸出流對象
ZipOutputStream zipOut=new ZipOutputStream(fos);
//創建指向壓縮原始文件的入口
ZipEntry entry=new ZipEntry(args[0]);
zipOut.putNextEntry(entry);
//向壓縮文件中輸出數據
int nNumber;
byte[] buffer=new byte[1024];
while((nNumber=fis.read(buffer))!=-1)
zipOut.write(buffer,0,nNumber);
//關閉創建的流對象
zipOut.close();
fos.close();
fis.close();
}
catch(IOException e)
{
System.out.println(e);
}

41.獲得應用程序完整路徑
String %%1=System.getProperty("user.dir");

42.ZIP解壓縮
/*
import java.io.*;
import java.util.zip.*;
*/
try{
//創建文件輸入流對象實例
FileInputStream fis=new FileInputStream(%%1);
//創建ZIP壓縮格式輸入流對象實例
ZipInputStream zipin=new ZipInputStream(fis);
//創建文件輸出流對象實例
FileOutputStream fos=new FileOutputStream(%%2);
//獲取Entry對象實例
ZipEntry entry=zipin.getNextEntry();
byte[] buffer=new byte[1024];
int nNumber;
while((nNumber=zipin.read(buffer,0,buffer.length))!=-1)
fos.write(buffer,0,nNumber);
//關閉文件流對象
zipin.close();
fos.close();
fis.close();
}
catch(IOException e) {
System.out.println(e);
}

43.遞歸刪除目錄中的文件
/*
import java.io.*;
import java.util.*;
*/
ArrayList<String> folderList = new ArrayList<String>();
folderList.add(%%1);
for (int j = 0; j < folderList.size(); j++) {
File file = new File(folderList.get(j));
File[] files = file.listFiles();
ArrayList<File> fileList = new ArrayList<File>();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
folderList.add(files[i].getPath());
} else {
fileList.add(files[i]);
}
}
for (File f : fileList) {
f.delete();
}
}

43.ZIP壓縮文件夾
/*
http://findjar.com/index.jsp
import java.io.*;
import org.apache.tools.zip.ZipOutputStream; //這個包在ant.jar里，要到官方網下載
//java.util.zip.ZipOutputStream
import java.util.zip.*;
*/
try {
String zipFileName = %%2; //打包後文件名字
File f=new File(%%1);
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
String base= "";
if (f.isDirectory()) {
File[] fl = f.listFiles();
out.putNextEntry(new org.apache.tools.zip.ZipEntry(base + "/"));
base = base.length() == 0 ? "" : base + "/";
for (int i = 0; i < fl.length; i++) {
zip(out, fl[i], base + fl[i].getName());
}
}else {
out.putNextEntry(new org.apache.tools.zip.ZipEntry(base));
FileInputStream in = new FileInputStream(f);
int b;
while ( (b = in.read()) != -1) {
out.write(b);
}
in.close();
}
out.close();
}catch (Exception ex) {
ex.printStackTrace();
}
/*
切，我剛好寫了個壓縮的，但沒寫解壓的

1. 解壓的(參數兩個，第一個是你要解壓的zip文件全路徑，第二個是你解壓之後要存放的位置)

/*
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
*/
public class ZipFileList {

public static void main(String[] args) {
extZipFileList(args[0],args[1]);
}

private static void extZipFileList(String zipFileName, String extPlace) {
try {
ZipInputStream in = new ZipInputStream(new FileInputStream(
zipFileName));
ZipEntry entry = null;
while ((entry = in.getNextEntry()) != null) {
String entryName = entry.getName();
if (entry.isDirectory()) {
File file = new File(extPlace + entryName);
file.mkdirs();
System.out.println("創建文件夾:" + entryName);
} else {
FileOutputStream os = new FileOutputStream(extPlace
+ entryName);
// Transfer bytes from the ZIP file to the output file
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
os.write(buf, 0, len);
}
os.close();
in.closeEntry();

}
}
} catch (IOException e) {
}
System.out.println("解壓文件成功");
}
}

壓縮的(參數最少傳兩個，第一個是你壓縮之後的文件存放的位置以及名字，第二個是你要壓縮的文件或者文件夾所在位置，也可以傳多個文件或文件夾)

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipFileOther {

public static String zipFileProcess(ArrayList outputZipFileNameList, String outputZipNameAndPath) {
ArrayList fileNames = new ArrayList();
ArrayList files = new ArrayList();
FileOutputStream fileOut = null;
ZipOutputStream outputStream = null;
FileInputStream fileIn = null;
StringBuffer sb = new StringBuffer(outputZipNameAndPath);
// FileInputStream fileIn =null;
try {
if (outputZipNameAndPath.indexOf(".zip") != -1) {
outputZipNameAndPath = outputZipNameAndPath;
} else {
sb.append(".zip");
outputZipNameAndPath = sb.toString();
}
fileOut = new FileOutputStream(outputZipNameAndPath);
outputStream = new ZipOutputStream(fileOut);
int outputZipFileNameListSize = 0;
if (outputZipFileNameList != null) {
outputZipFileNameListSize = outputZipFileNameList.size();
}
for (int i = 0; i < outputZipFileNameListSize; i++) {
File rootFile = new File(outputZipFileNameList.get(i).toString());
listFile(rootFile, fileNames, files, "");
}
for (int loop = 0; loop < files.size(); loop++) {
fileIn = new FileInputStream((File) files.get(loop));
outputStream.putNextEntry(new ZipEntry((String) fileNames.get(loop)));
byte[] buffer = new byte[1024];
while (fileIn.read(buffer) != -1) {
outputStream.write(buffer);
}
outputStream.closeEntry();
fileIn.close();
}
return outputZipNameAndPath;
} catch (IOException ioe) {
return null;
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
}
}
if (fileIn != null) {
try {
fileIn.close();
} catch (IOException e) {
}
}
}
}

public static void main(String[] args) {
ArrayList outputZipFileName=new ArrayList();
String savePath="";
int argSize = 0;
if (args != null) {
argSize = args.length;
}

if (argSize > 1) {
if(args[0]!=null)
savePath = args[0];
for(int i=1;i<argSize;i++){
if(args[i]!=null){
outputZipFileName.add(args[i]);
}
}
ZipFileOther instance=new ZipFileOther();
instance.zipFileProcess(outputZipFileName,savePath);
} else {
}

}

private static void listFile(File parentFile, List nameList, List fileList, String directoryName) {
if (parentFile.isDirectory()) {
File[] files = parentFile.listFiles();
for (int loop = 0; loop < files.length; loop++) {
listFile(files[loop], nameList, fileList, directoryName + parentFile.getName() + "/");
}
} else {
fileList.add(parentFile);
nameList.add(directoryName + parentFile.getName());
}
}
}

*/

Ⅹ 怎樣用java快速實現zip文件的壓縮解壓縮

packagezip;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.util.Enumeration;
importjava.util.zip.CRC32;
importjava.util.zip.CheckedOutputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipFile;
importjava.util.zip.ZipOutputStream;
importorg.apache.commons.lang3.StringUtils;
publicclassZipUtil{
	
	/**
	*遞歸壓縮文件夾
	*@paramsrcRootDir壓縮文件夾根目錄的子路徑
	*@paramfile當前遞歸壓縮的文件或目錄對象
	*@paramzos壓縮文件存儲對象
	*@throwsException
	*/
	privatestaticvoidzip(StringsrcRootDir,Filefile,ZipOutputStreamzos)throwsException
	{
		if(file==null)
		{
			return;
		}				
		
		//如果是文件，則直接壓縮該文件
		if(file.isFile())
		{			
			intcount,bufferLen=1024;
			bytedata[]=newbyte[bufferLen];
			
			//獲取文件相對於壓縮文件夾根目錄的子路徑
			StringsubPath=file.getAbsolutePath();
			intindex=subPath.indexOf(srcRootDir);
			if(index!=-1)
			{
				subPath=subPath.substring(srcRootDir.length()+File.separator.length());
			}
			ZipEntryentry=newZipEntry(subPath);
			zos.putNextEntry(entry);
			BufferedInputStreambis=newBufferedInputStream(newFileInputStream(file));
			while((count=bis.read(data,0,bufferLen))!=-1)
			{
				zos.write(data,0,count);
			}
			bis.close();
			zos.closeEntry();
		}
		//如果是目錄，則壓縮整個目錄
		else
		{
			//壓縮目錄中的文件或子目錄
			File[]childFileList=file.listFiles();
			for(intn=0;n<childFileList.length;n++)
			{
				childFileList[n].getAbsolutePath().indexOf(file.getAbsolutePath());
				zip(srcRootDir,childFileList[n],zos);
			}
		}
	}
	
	/**
	*對文件或文件目錄進行壓縮
	*@paramsrcPath要壓縮的源文件路徑。如果壓縮一個文件，則為該文件的全路徑；如果壓縮一個目錄，則為該目錄的頂層目錄路徑
	*@paramzipPath壓縮文件保存的路徑。注意：zipPath不能是srcPath路徑下的子文件夾
	*@paramzipFileName壓縮文件名
	*@throwsException
	*/
	publicstaticvoidzip(StringsrcPath,StringzipPath,StringzipFileName)throwsException
	{
		if(StringUtils.isEmpty(srcPath)||StringUtils.isEmpty(zipPath)||StringUtils.isEmpty(zipFileName))
		{
			thrownewParameterException(ICommonResultCode.PARAMETER_IS_NULL);
		}
		CheckedOutputStreamcos=null;
		ZipOutputStreamzos=null;						
		try
		{
			FilesrcFile=newFile(srcPath);
			
			//判斷壓縮文件保存的路徑是否為源文件路徑的子文件夾，如果是，則拋出異常（防止無限遞歸壓縮的發生）
			if(srcFile.isDirectory()&&zipPath.indexOf(srcPath)!=-1)
			{
				thrownewParameterException(ICommonResultCode.INVALID_PARAMETER,".");
			}
			
			//判斷壓縮文件保存的路徑是否存在，如果不存在，則創建目錄
			FilezipDir=newFile(zipPath);
			if(!zipDir.exists()||!zipDir.isDirectory())
			{
				zipDir.mkdirs();
			}
			
			//創建壓縮文件保存的文件對象
			StringzipFilePath=zipPath+File.separator+zipFileName;
			FilezipFile=newFile(zipFilePath);			
			if(zipFile.exists())
			{
				//檢測文件是否允許刪除，如果不允許刪除，將會拋出SecurityException
				=newSecurityManager();
				securityManager.checkDelete(zipFilePath);
				//刪除已存在的目標文件
				zipFile.delete();				
			}
			
			cos=newCheckedOutputStream(newFileOutputStream(zipFile),newCRC32());
			zos=newZipOutputStream(cos);
			
			//如果只是壓縮一個文件，則需要截取該文件的父目錄
			StringsrcRootDir=srcPath;
			if(srcFile.isFile())
			{
				intindex=srcPath.lastIndexOf(File.separator);
				if(index!=-1)
				{
					srcRootDir=srcPath.substring(0,index);
				}
			}
			//調用遞歸壓縮方法進行目錄或文件壓縮
			zip(srcRootDir,srcFile,zos);
			zos.flush();
		}
		catch(Exceptione)
		{
			throwe;
		}
		finally
		{			
			try
			{
				if(zos!=null)
				{
					zos.close();
				}				
			}
			catch(Exceptione)
			{
				e.printStackTrace();
			}			
		}
	}
	
	/**
	*解壓縮zip包
	*@paramzipFilePathzip文件的全路徑
	*@paramunzipFilePath解壓後的文件保存的路徑
	*@paramincludeZipFileName解壓後的文件保存的路徑是否包含壓縮文件的文件名。true-包含；false-不包含
	*/
	@SuppressWarnings("unchecked")
	publicstaticvoinzip(StringzipFilePath,StringunzipFilePath,booleanincludeZipFileName)throwsException
	{
		if(StringUtils.isEmpty(zipFilePath)||StringUtils.isEmpty(unzipFilePath))
		{
			thrownewParameterException(ICommonResultCode.PARAMETER_IS_NULL);			
		}
		FilezipFile=newFile(zipFilePath);
		//如果解壓後的文件保存路徑包含壓縮文件的文件名，則追加該文件名到解壓路徑
		if(includeZipFileName)
		{
			StringfileName=zipFile.getName();
			if(StringUtils.isNotEmpty(fileName))
			{
				fileName=fileName.substring(0,fileName.lastIndexOf("."));
			}
			unzipFilePath=unzipFilePath+File.separator+fileName;
		}
		//創建解壓縮文件保存的路徑
		FileunzipFileDir=newFile(unzipFilePath);
		if(!unzipFileDir.exists()||!unzipFileDir.isDirectory())
		{
			unzipFileDir.mkdirs();
		}
		
		//開始解壓
		ZipEntryentry=null;
		StringentryFilePath=null,entryDirPath=null;
		FileentryFile=null,entryDir=null;
		intindex=0,count=0,bufferSize=1024;
		byte[]buffer=newbyte[bufferSize];
		BufferedInputStreambis=null;
		BufferedOutputStreambos=null;
		ZipFilezip=newZipFile(zipFile);
		Enumeration<ZipEntry>entries=(Enumeration<ZipEntry>)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=newFile(entryDirPath);
			//如果文件夾路徑不存在，則創建文件夾
			if(!entryDir.exists()||!entryDir.isDirectory())
			{
				entryDir.mkdirs();
			}
			
			//創建解壓文件
			entryFile=newFile(entryFilePath);
			if(entryFile.exists())
			{
				//檢測文件是否允許刪除，如果不允許刪除，將會拋出SecurityException
				=newSecurityManager();
				securityManager.checkDelete(entryFilePath);
				//刪除已存在的目標文件
				entryFile.delete();	
			}
			
			//寫入文件
			bos=newBufferedOutputStream(newFileOutputStream(entryFile));
			bis=newBufferedInputStream(zip.getInputStream(entry));
			while((count=bis.read(buffer,0,bufferSize))!=-1)
			{
				bos.write(buffer,0,count);
			}
			bos.flush();
			bos.close();			
		}
	}
	
	publicstaticvoidmain(String[]args)
	{
		StringzipPath="d:\ziptest\zipPath";
		Stringdir="d:\ziptest\rawfiles";
		StringzipFileName="test.zip";
		try
		{
			zip(dir,zipPath,zipFileName);
		}
		catch(Exceptione)
		{
			e.printStackTrace();
		}
		
		StringzipFilePath="D:\ziptest\zipPath\test.zip";
		StringunzipFilePath="D:\ziptest\zipPath";
		try
		{
			unzip(zipFilePath,unzipFilePath,true);
		}
		catch(Exceptione)
		{
			e.printStackTrace();
		}
	}
}