java多文件解压缩代码 java压缩文件解压

怎样用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的解压缩的代码？

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代码调用解压工具去解压.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:\\");

在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 ArrayListStringextensions = new ArrayListString();

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多文件解压缩代码 java压缩文件解压
路径分享：https://www.cdcxhl.com/article10/dogdsgo.html

成都网站建设公司_创新互联，为您提供手机网站建设、网站设计、ChatGPT、品牌网站建设、外贸建站、自适应网站

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容