javazip打包文件夹

1. 如何使用java压缩文件夹成为zip包（最简单的

import java.io.File;

public class ZipCompressorByAnt {

private File zipFile;

/**
* 压缩文件构造函数
* @param pathName 最终压缩生成的压缩文件：目录+压缩文件名.zip
*/
public ZipCompressorByAnt(String finalFile) {
zipFile = new File(finalFile);
}

/**
* 执行压缩操作
* @param srcPathName 需要被压缩的文件/文件夹
*/
public void compressExe(String srcPathName) {
System.out.println("srcPathName="+srcPathName);

File srcdir = new File(srcPathName);
if (!srcdir.exists()){
throw new RuntimeException(srcPathName + "不存在！");
}

Project prj = new Project();
Zip zip = new Zip();
zip.setProject(prj);
zip.setDestFile(zipFile);
FileSet fileSet = new FileSet();
fileSet.setProject(prj);
fileSet.setDir(srcdir);
//fileSet.setIncludes("**/*.java"); //包括哪些文件或文件夹 eg:zip.setIncludes("*.java");
//fileSet.setExcludes(...); //排除哪些文件或文件夹
zip.addFileset(fileSet);
zip.execute();
}

}

public class TestZip {

public static void main(String[] args) {

ZipCompressorByAnt zca = new ZipCompressorByAnt("E:\test1.zip ");
zca.compressExe("E:\test1");
}

}

/*如果 出现ant 的 52 51 50 等版本问题 可以去找对应的ant-1.8.2.jar 我开始用的ant-1.10.1.jar 就是这个包版本高了 一直报verson 52 版本问题*/

2. java如何实现多个文件的压缩

importjava.util.*;
importjava.net.URI;
importjava.nio.file.Path;
importjava.nio.file.*;

publicclassZipFSPUser{
publicstaticvoidmain(String[]args)throwsThrowable{
Map<String,String>env=newHashMap<>();
env.put("create","true");
//
//definedinjava.net.JarURLConnection
URIuri=URI.create("jar:file:/codeSamples/zipfs/zipfstest.zip");

try(FileSystemzipfs=FileSystems.newFileSystem(uri,env)){
PathexternalTxtFile=Paths.get("/codeSamples/zipfs/SomeTextFile.txt");
PathpathInZipfile=zipfs.getPath("/SomeTextFile.txt");
//afileintothezipfile
Files.(externalTxtFile,pathInZipfile,
StandardCopyOption.REPLACE_EXISTING);
}
}
}

创建一个zip文件，并添加一个文件进去，需要JDK7

3. java怎样压缩文件夹

压缩文件夹代码:
import java.io.File;
import org.apache.tools.zip.ZipOutputStream; //这个包在ant.jar里，要到官方网下载
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipEntry;

public class CompressBook {
public CompressBook() {}

/*
* inputFileName 输入一个文件夹
* zipFileName 输出一个压缩文件夹
*/
public void zip(String inputFileName) throws Exception {
String zipFileName = "c:\\test.zip"; //打包后文件名字
System.out.println(zipFileName);
zip(zipFileName, new File(inputFileName));
}

private void zip(String zipFileName, File inputFile) throws Exception {
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
zip(out, inputFile, "");
System.out.println("zip done");
out.close();
}

private void zip(ZipOutputStream out, File f, String base) throws Exception {
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;
System.out.println(base);
while ( (b = in.read()) != -1) {
out.write(b);
}
in.close();
}
}

public static void main(String [] temp){
CompressBook book = new CompressBook();
try {
book.zip("c:\\c");//你要压缩的文件夹
}catch (Exception ex) {
ex.printStackTrace();
}
}
}

4. 怎样用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();
		}
	}
}

5. java中将一个文件夹下所有的文件压缩成一个文件,然后,解压到指定目录.

import java.io.*;
import java.util.zip.*;
public class CompressD {
// 缓冲
static byte[] buffer = new byte[2048];
public static void main(String[] args) throws Exception {
// 来源
File inputDir = new File("C:\\CompressTest\\");
// 目标
FileOutputStream fos = new FileOutputStream("C:\\CompressTest.zip");
// 过滤
ZipOutputStream zos = new ZipOutputStream(fos);
// 压缩
zip(inputDir.listFiles(), "", zos);
// 关闭
zos.close();
}
private static void zip(File[] files, String baseFolder, ZipOutputStream zos)
throws Exception {
// 输入
FileInputStream fis = null;
// 条目
ZipEntry entry = null;
// 数目
int count = 0;
for (File file : files) {
if (file.isDirectory()) {
// 递归
zip(file.listFiles(), file.getName() + File.separator, zos);
continue;
}
entry = new ZipEntry(baseFolder + file.getName());
// 加入
zos.putNextEntry(entry);
fis = new FileInputStream(file);
// 读取
while ((count = fis.read(buffer, 0, buffer.length)) != -1)
// 写入
zos.write(buffer, 0, count);
}
}
}

6. java 如何将多个文件打包成一个zip后进行下载

打包压缩的如下：
ZipOutputStream out=new ZipOutputStream(new FileOutputStream(zipFileName));
for(int i=0;i<fileList.size();i++){
String filename = (String)fileList.get(i);
File file = new File(filename);
zip(out,file);
}
out.close();

下载的如下：
private int blockSize=65000;
File file = new File(sourceFilePathName);
FileInputStream fileIn = new FileInputStream(file);
int readBytes = 0;
readBytes = fileIn.read(b, 0, blockSize);
totalRead += readBytes;
out.write(b, 0, readBytes);

代码大致如此，请参考。

7. java怎么将文件打包成zip包，并且源文件还在，只是多了个zip包，网上多是直接压缩的，导致源文件不在了

选择这个添加到压缩文件，就是保留之前的，多出一份压缩的啊

8. java 如何将多个文件打包成一个zip

java 将多个文件打包成一个zip的代码如下：
ZipOutputStream out=new ZipOutputStream(new FileOutputStream(zipFileName));
for(int i=0;i<fileList.size();i++){
String filename = (String)fileList.get(i);
File file = new File(filename);
zip(out,file);
}
out.close();

9. java web 将文件打包成 .zip后 怎么自动弹出下载框提示并下载

方法一：jquery的ajax实现

方法二：打包氏核樱成功后，返回前台，一个标记，歼丛前台js弹出框提氏埋示

10. java zip 是否有文件夹

写出绝对路径或者相对路径才有地方相应的压缩。
package com.han;

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

/**
* 程序实现了ZIP压缩。共分为2部分 ： 压缩（compression）与解压（decompression）
* <p>
* 大致功能包括用了多态，递归等JAVA核心技术，可以对单个文件和任意级联文件夹进行压缩和解压。 需在代码中自定义源输入路径和目标输出路径。
* <p>
* 在本段代码中，实现的是压缩部分；解蔽脊压部分见本包中Decompression部分。
*
* @author HAN
*
*/

public class MyZipCompressing {
private int k = 1; // 定义递归次数变量

public MyZipCompressing() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyZipCompressing book = new MyZipCompressing();
try {
book.zip("C:\\Users\\Gaowen\\Desktop\\ZipTestCompressing.zip",
new File("C:\\Users\\Gaowen\\Documents\\Tencent Files"));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

private void zip(String zipFileName, File inputFile) throws Exception {
System.out.println("压缩中...");
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
zipFileName));
BufferedOutputStream bo = new BufferedOutputStream(out);
zip(out, inputFile, inputFile.getName(), bo);
bo.close();
out.close(); // 输出流关闭
System.out.println("压缩完成");
}

private void zip(ZipOutputStream out, File f, String base,
BufferedOutputStream bo) throws Exception { // 方法重载
if (f.isDirectory()) {
File[] fl = f.listFiles();
if (fl.length == 0) {
out.putNextEntry(new ZipEntry(base + "/")); //宏嫌渗 创建zip压缩进入点base
System.out.println(base + "/");
}
for (int i = 0; i < fl.length; i++) {
zip(out, fl[i], base + "/" + fl[i].getName(), bo); // 递归遍历子文件夹
}
System.out.println("第" + k + "次递归");
k++;
} else {
out.putNextEntry(new ZipEntry(base)); // 创建zip压者弯缩进入点base
System.out.println(base);
FileInputStream in = new FileInputStream(f);
BufferedInputStream bi = new BufferedInputStream(in);
int b;
while ((b = bi.read()) != -1) {
bo.write(b); // 将字节流写入当前zip目录
}
bi.close();
in.close(); // 输入流关闭
}
}
}