java壓縮包解壓

㈠ 用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里怎麼解壓tar.gz文件啊，網上好多例子都不行

最後怎麼解決的，我現在也遇到這個問題了，單個文件可以解壓可以壓縮，寫入的測試內容也在，換成文件夾就不行了。能找到的案例全都是解壓成文件，但是本身是個文件夾的GZ包解壓了以後也打不開。

㈢ java解壓zip文件

import java.io.IOException;
import java.util.Enumeration;
import java.util.zip.ZipEntry;

/**
* 獲得zip文件里的所有文件
* @author Administrator
*
*/
public class ZipFile {

public ZipFile() throws IOException
{
java.util.zip.ZipFile zf = new java.util.zip.ZipFile("E:/Java/Project.zip");
Enumeration e = zf.entries();
while(e.hasMoreElements())
{
ZipEntry ze = (ZipEntry) e.nextElement();
if(!ze.isDirectory())
System.out.println(new String(ze.getName().getBytes("ISO-8859-1"), "GB2312"));
}
}
public static void main(String[] args) {
try {
new ZipFile();
} catch (IOException e) {
e.printStackTrace();
}
}

}

㈣ java 中的war格式的壓縮包怎麼解壓

你好,這些是打包好的部署包,將這些直接丟如Tomcat WebApp目錄下就可以通過Web訪問了,如果你想看源碼,用解壓縮軟體都可以的,就看這包裡面有沒有源碼了,zip ,winRAR ,7-zip都可以解壓出來,如果想看源碼,沒有的話,找個反編譯的軟體把class文件拖進去就可以看到了..jd-gui 這個可以,網上找找

㈤ javazip壓縮包過大解壓失敗

javazip壓縮包過大解壓失敗的原因:網路傳輸不好導致文件下載損壞、網站提供的RAR壓縮包最初被損壞、使用的下載工具不夠完善。我們可以通過壓縮軟體里的「修復壓縮文件」解決javazip壓縮包過大解壓失敗的問題。

㈥ java如何解壓頁面上傳到伺服器的zip文件

這個轉換肯定是會出錯的，struts 的formFile跟zipFile沒有直接關系，怎麼能這么強制轉化呢？
建議
1. 把文件保存到一個臨時目錄（保存為zip文件）
2. 讀取這個文件
3. 抽取想要的文件
4. 把臨時文件刪除

㈦ 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實現ftp側壓縮文件的解壓

我們在開發項目的時候,特別是B/S系統,經常會遇到要批量上傳文件的需求,對此需求一般有如下幾個解決方案(以B/S為例):1. 在客戶端提供文件上傳介面,一次上傳一個文件2. 一次上傳多個文件3. 將需要上傳的文件打包,一次上傳到伺服器,並自動解凳脊慶壓到指定目錄1,2方法都有幾個很明顯的不足,用戶工作量大,文件如果過大,在網路環境野局中,上傳的效率低下,另外文件在不同的目錄,是無法進行一次選擇上傳的.所以打包上傳就成為了比較流行的批量文件上傳的解決方案,下面就來一起討論一下在java中如何實現: 主要功能需求: a. 上傳文件,將文件保存在伺服器 b. 讀取伺服器上壓縮文件,解壓到指定目錄 下面就這兩個需求說說編碼實現上傳: 使用了smartupload開源程序 參考鏈棗握接: http://hi..com/liuzy84/blog/item/556318f4fad1cc6fddc4741a.html

㈨ 在java中，gzip 壓縮和解壓多個文件

直接編譯運行！！！

不知道你是要查看壓縮文件還是要解壓文件，所以發上來兩個。
第一個可以查看各個壓縮項目；
第二個可以解壓文件。

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.util.zip.*;
import javax.swing.*;
import javax.swing.filechooser.FileFilter;

class ZipTest {
public static void main(String[] args) {
ZipTestFrame frame = new ZipTestFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

class ZipTestFrame extends JFrame {

private JComboBox fileCombo;
private JTextArea fileText;
private String zipname;

public ZipTestFrame() {

setTitle("ZipTest");
setSize(400,300);

JMenuBar menuBar = new JMenuBar();
JMenu menu = new JMenu("File");

JMenuItem openItem = new JMenuItem("Open");
menu.add(openItem);
openItem.addActionListener(new OpenAction());

JMenuItem exitItem = new JMenuItem("Exit");
menu.add(exitItem);
exitItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.exit(0);
}
});

menuBar.add(menu);
setJMenuBar(menuBar);

fileText = new JTextArea();
fileCombo = new JComboBox();
fileCombo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
loadZipFile((String)fileCombo.getSelectedItem());
}
});
add(fileCombo, BorderLayout.SOUTH);
add(new JScrollPane(fileText), BorderLayout.CENTER);
}

public class OpenAction implements ActionListener {
public void actionPerformed(ActionEvent event) {
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
ExtensionFileFilter filter = new ExtensionFileFilter();
filter.addExtension(".zip");
filter.addExtension(".jar");
filter.setDescription("ZIP archives");
chooser.setFileFilter(filter);
int r = chooser.showOpenDialog(ZipTestFrame.this);
if(r == JFileChooser.APPROVE_OPTION) {
zipname = chooser.getSelectedFile().getPath();
scanZipFile();
}
}
}

public void scanZipFile() {
fileCombo.removeAllItems();
try {
ZipInputStream zin = new ZipInputStream(new FileInputStream(zipname));
ZipEntry entry;
while((entry = zin.getNextEntry()) != null) {
fileCombo.addItem(entry.getName());
zin.closeEntry();
}
zin.close();
} catch(IOException e) {
e.printStackTrace();
}
}

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 line;
while((line = in.readLine())!=null) {
fileText.append(line);
fileText.append("\n");
}
}
zin.closeEntry();
}
zin.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}

class ExtensionFileFilter extends FileFilter {

private String description = "";
private ArrayList<String>extensions = new ArrayList<String>();

public void addExtension(String extension) {
if(!extension.startsWith("."))
extension = "." + extension;
extensions.add(extension.toLowerCase());
}

public void setDescription(String aDescription) {
description = aDescription;
}

public String getDescription() {
return description;
}

public boolean accept(File f) {
if(f.isDirectory()) return true;
String name = f.getName().toLowerCase();

for(String e : extensions)
if(name.endsWith(e))
return true;
return false;
}
}

///////////////////////////////////////////////////////////
/**
*類名：zipFileRelease
*說明：一個zip文件解壓類
*介紹：主要的zip文件釋放方法releaseHandle()
* 用ZipInputStream類和ZipEntry類將zip文件的入口清單列舉出來，然後
* 根據用戶提供的輸出路徑和zip文件的入口進行組合通過DataOutputStream
* 和File類進行文件的創建和目錄的創建，創建文件時的文件數據是通過
* ZipInputStream類、ZipEntry類、InputStream類之間的套嵌組合獲得的。
*注意：如果zip文件中包含中文路徑程序將會拋出異常
*/

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實現壓縮視頻文件，但是壓縮後並解壓，提示文件損壞，我該怎麼修改代碼

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