java ant的zip札记
java ant的zip笔记
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;
public class ZipUtil {
/**
* 不准实例对象
*/
private ZipUtil() {
}
/**
* 压缩
*
* @param lists
* 添加的文件列表
* @param fileDest
* 目标zip文件的路径
* @throws IOException
*/
public static void zip(List<String> lists, String fileDest)
throws Exception {
if (lists == null || lists.size() <= 0) {
throw new Exception("file list is empty!");
} else {
File destFile = new File(fileDest);
OutputStream output = null;
ZipOutputStream zipOut = null;
if (destFile.exists()) {
throw new Exception("target file Already exists!");
} else {
try {
output = new FileOutputStream(destFile, false);
} catch (Exception e) {
throw new Exception("target directory must exists!");
}
zipOut = new ZipOutputStream(output);
for (String filePath : lists) {
File file = new File(filePath);
if (file.exists()) {
List<String> temps = new ArrayList<String>();
recursionFiles(file.getPath(), temps);
for (String p : temps) {
recursionZipFile(p, zipOut);
}
//recursionZipFile(file.getPath(), zipOut);
} else {
if (zipOut != null) {
zipOut.closeEntry();
try {
zipOut.close();
} catch (Exception e1) {
destFile.delete(); // delete already zipfile
e1.printStackTrace();
}
zipOut = null;
}
if (output != null) {
output.flush();
try {
output.close();
} catch (Exception e1) {
destFile.delete(); // delete already zipfile
e1.printStackTrace();
}
output = null;
}
destFile.delete();
throw new Exception("target file not exists!");
}
}
// close stream object
closeStream(zipOut, output, destFile);
}
}
}
/**
* @param file
* 添加的单个文件
* @param fileDest
* 目标zip文件的路径
* @throws Exception
*/
public static void zip(String file, String fileDest) throws Exception {
File srcFile = new File(file);
if (srcFile.exists()) {
File destFile = new File(fileDest);
OutputStream output = null;
ZipOutputStream zipOut = null;
if (destFile.exists()) {
throw new Exception("target file Already exists!");
} else {
try {
output = new FileOutputStream(destFile, false);
} catch (Exception e) {
throw new Exception("target directory must exists!");
}
zipOut = new ZipOutputStream(output);
try {
recursionZipFile(srcFile.getPath(), zipOut);
} catch (Exception e) {
closeStream(zipOut, output, destFile);
e.printStackTrace();
}
// close stream object
closeStream(zipOut, output, destFile);
}
} else {
throw new Exception("target file not exists!");
}
}
/**
* @param zipSrc
* zip源文件路径
* @param fileDest
* 解压的文件路径
* @throws Exception
*/
public static void unzip(String zipSrc, String fileDest) throws Exception {
File f = new File(zipSrc);
if (f.exists()) {
File file = new File(fileDest);
if (file.exists() && file.isDirectory()) {
ZipFile zipFile = new ZipFile(f);
for (@SuppressWarnings("rawtypes")
Enumeration entries = zipFile.getEntries(); entries
.hasMoreElements();) {
try {
ZipEntry zipEntry = (ZipEntry) entries.nextElement();
InputStream ins = zipFile.getInputStream(zipEntry);
int index = zipEntry.getName().lastIndexOf("/") + 1;
if (index <= 0) {
index = zipEntry.getName().lastIndexOf("\\") + 1;
}
file = new File(fileDest
+ "/"
+ zipEntry.getName().substring(0, index)
+ "/"
+ zipEntry.getName().substring(index,
zipEntry.getName().length()));
File parentPath = new File(file.getParent());
if (!parentPath.isDirectory()) {
parentPath.mkdirs();
}
String absPath = file.getPath().replaceAll("\\\\", "/");
OutputStream output = new FileOutputStream(absPath);
int len=-1;
byte [] b=new byte[1024];
while((len=ins.read(b))!=-1){
output.write(b, 0, len);
}
output.flush();
output.close();
ins.close();
} catch (Exception e) {
delete(fileDest, false); // delete already unzip file
e.printStackTrace();
}
}
zipFile.close();
} else {
throw new Exception("target directory not exists!");
}
} else {
throw new Exception("src file not exists!");
}
}
/**
*
* @param lists
* 追加的文件列表
* @param zipDest
* 要追加的zip文件
*/
@SuppressWarnings("unchecked")
public static void zipAppend(List<String> lists, String zipDest)
throws Exception {
File zipRoot = new File(zipDest);
String suffix = zipRoot.getPath().substring(
zipRoot.getPath().lastIndexOf("zip"));
boolean isException = true;
if (zipRoot.isFile() && "zip".equals(suffix)) {
if (lists != null && lists.size() > 0) {
File destFile = new File(zipDest);
ZipFile zipFile = new ZipFile(zipRoot);
OutputStream output = null;
ZipOutputStream zipOut = null;
for (int i = 0; i < lists.size(); i++) {
isException = exists(lists.get(i), false);
}
try {
@SuppressWarnings("rawtypes")
List list = new ArrayList();
List<String> existsFile = new ArrayList<String>();
if (isException) {
// 先添加原来的
for (@SuppressWarnings("rawtypes")
Enumeration entries = zipFile.getEntries(); entries
.hasMoreElements();) {
try {
List<Object> oldFile = new ArrayList<Object>();
ZipEntry zipEntry = (ZipEntry) entries
.nextElement();
InputStream ins = zipFile
.getInputStream(zipEntry);
long size = zipEntry.getSize();
String name = zipEntry.getName();
/**
* assets/picture/1-1.png
* assets/mousePic/1uparrow2.png
*/
for (int i = 0; i < lists.size(); i++) {
String newsName = lists.get(i).toString();
List<String> temps = new ArrayList<String>();
recursionFiles(newsName, temps);
for (int j = 0; j < temps.size(); j++) {
String tempName = name;
if (tempName.indexOf("/") != -1) {
tempName = tempName.replaceAll("/",
"\\\\");
}
String tp = (zipRoot.getParent() + tempName)
.replaceAll("\\\\", "/")
.toLowerCase();
String sp = temps.get(j)
.replaceAll("\\\\", "/")
.toLowerCase();
if (tp.equals(sp)) {
// 用最后新的文件路径替换前面己有路径，这是为了，用后面的覆盖前面的文件
ins = new FileInputStream(new File(
temps.get(j)));
size = ins.available();
existsFile.add(temps.get(j)); // 添加存在的住合里面去
}
}
}
byte[] b = new byte[(int) size];
// long begin=System.currentTimeMillis();
for (int i = 0; i < size; i++) {
byte c = (byte) ins.read();
// 存入临时缓存
b[i] = c;
}
ins.close();
oldFile.add(name);
oldFile.add(b);
list.add(oldFile);
} catch (Exception e) {
isException = false;
e.printStackTrace();
}
}
} else {
throw new Exception("target file format error");
}
if (isException) {
try {
output = new FileOutputStream(destFile);
} catch (Exception e) {
throw new Exception(e);
}
zipOut = new ZipOutputStream(output);
// 原来的
for (int i = 0; i < list.size(); i++) {
List<Object> oldFile = (List<Object>) list.get(i);
String name = oldFile.get(0).toString();
byte[] b = (byte[]) oldFile.get(1);
ZipEntry zipEntry = new ZipEntry(name);
zipOut.putNextEntry(zipEntry);
zipOut.write(b, 0, b.length);
}
// 再添加后面的
for (int i = 0; i < lists.size(); i++) {
String path = lists.get(i).replaceAll("\\\\", "/");
List<String> temps = new ArrayList<String>();
recursionFiles(path, temps);
// 选出不存在的
for (int j = 0; j < existsFile.size(); j++) {
if (temps.contains(existsFile.get(j))) {
temps.remove(existsFile.get(j)); // 这一步是为了移除旧的文件
}
}
for (String p : temps) {
recursionZipFile(p, zipOut);
}
}
} else {
throw new Exception("target file format error");
}
} catch (Exception e) {
closeStream(zipOut, output, destFile);
e.printStackTrace();
}
// close stream object
closeStream(zipOut, output, destFile);
} else {
throw new Exception("lists empty!");
}
} else {
throw new Exception("target file format error");
}
}
/**
* 关闭流
*
* @param zipOut
* @param output
* @param destFile
*/
private static void closeStream(ZipOutputStream zipOut,
OutputStream output, File destFile) {
if (zipOut != null) {
try {
zipOut.closeEntry();
zipOut.flush();
zipOut.close();
} catch (Exception e) {
destFile.delete();
e.printStackTrace();
}
zipOut = null;
}
if (output != null) {
try {
output.flush();
output.close();
} catch (Exception e) {
destFile.delete();
e.printStackTrace();
}
output = null;
}
}
/**
* 这是递归删除,当前目录下所有文件都将删除
*
* @param p
* 路径
* @param dp
* 是否删除当前目录
* @throws Exception
*/
private static void delete(String p, boolean dp) throws Exception {
File rootFile = new File(p);
if (rootFile.exists()) {
String[] files = rootFile.list();
for (int i = 0; i < files.length; i++) {
String path = (rootFile.getPath() + "\\" + files[i])
.replaceAll("\\\\", "/");
File elementFile = new File(path);
if (elementFile.isDirectory()) {
delete(elementFile.getPath(), true);
} else {
if (!elementFile.delete()) {
throw new Exception("delete Failed!");
}
}
}
} else {
throw new Exception("target directory not exists!");
}
if (dp) {
if (!rootFile.delete()) {
throw new Exception("delete Failed!");
}
}
}
/**
* @param base
* @param path
* @param entry
* @param zipOut
*/
private static void recursionZipFile(String path, ZipOutputStream zipOut) {
try {
File f = new File(path);
FileInputStream input = new FileInputStream(f.getPath());
String base = "";
String temppath = f.getPath().replaceAll("\\\\", "/");
String xg[] = temppath.split("/");
/**
* 下面这个主要是为了确定父文件夹
*/
if (xg.length == 2) {
base = "";
} else if (xg.length > 2) {
base = temppath.substring(temppath.indexOf("/") + 1,
temppath.lastIndexOf("/") + 1);
}
String savepath = base + f.getName();
ZipEntry entry = new ZipEntry(savepath);
zipOut.putNextEntry(entry);
int len = 0;
byte[] b = new byte[1024];
while ((len = input.read(b)) != -1) {
zipOut.write(b, 0, len);
}
input.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 递归一个文件夹下所有文件
*
* @param path
* @param returnList
* @return
*/
private static List<String> recursionFiles(String path,
List<String> returnList) {
File filepath = new File(path.replaceAll("\\\\", "/"));
if (filepath.exists()) {
if (filepath.isDirectory()) {
String[] files = filepath.list();
for (int i = 0; i < files.length; i++) {
String newsPath = filepath.getPath() + "/" + files[i];
newsPath = newsPath.replaceAll("\\\\", "/");
File elementFile = new File(newsPath);
if (elementFile.exists()) {
if (elementFile.isFile()) {
returnList.add(elementFile.getPath());
} else if (elementFile.isDirectory()) {
recursionFiles(newsPath, returnList);// 再遍历
}
} else {
returnList = new ArrayList<String>();
break;
}
}
} else {
returnList.add(filepath.getPath());
}
} else {
returnList = new ArrayList<String>();
}
return returnList;
}
/**
* 判断一个文件夹下所有文件是否确实存在
*
* @param path
* @param exists
* @return
*/
private static boolean exists(String path, boolean exists) {
File filepath = new File(path.replaceAll("\\\\", "/"));
if (filepath.exists()) {
if (filepath.isDirectory()) {
String[] files = filepath.list();
for (int i = 0; i < files.length; i++) {
String newsPath = filepath.getPath() + "/" + files[i];
newsPath = newsPath.replaceAll("\\\\", "/");
File elementFile = new File(newsPath);
if (elementFile.exists()) {
if (elementFile.isFile()) {
exists = true;
} else if (elementFile.isDirectory()) {
exists(newsPath, false);// 再遍历
}
} else {
exists = false;
}
}
} else {
exists = true;
}
} else {
exists = false;
}
return exists;
}
public static void main(String[] args) throws Exception {
// delete("D:\\aa", true);
// testzipAppend();
// List<String> fileList = new ArrayList<String>();
// fileList.add("D:\\图片.png");
// fileList.add("D:\\assets");
// fileList.add("D:\\projectsw.xml");
// fileList.add("D:\\assets\\aa.png");
// for(int i=0;i<fileList.size();i++){
//
// System.out.println(exists(fileList.get(i), false));
// }
testunZIP();
}
private static void testZIP() {
List<String> fileList = new ArrayList<String>();
fileList.add("D:\\图片.png");
fileList.add("D:\\assets");
fileList.add("D:\\My Documents\\F5\\projects.xml");
String srcFile = "D:\\My Documents\\F5\\projects.xml";
String fileDest = "D:\\zip-2.zip";
try {
zip(fileList, fileDest);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void testunZIP() {
String srcFile = "D:\\dddd.zip";
String destFile = "D:\\aa";
try {
unzip(srcFile, destFile);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void testzipAppend() throws Exception {
List<String> fileList = new ArrayList<String>();
fileList.add("D:\\图片.png");
fileList.add("D:\\assets");
fileList.add("D:\\projects.xml");
String fileDest = "D:\\dddd.zip";
zipAppend(fileList, fileDest);
}
private static void buffer() {
File file = new File("D:\\waterMarkImage.jpg");
InputStream in;
try {
in = new FileInputStream(file);
BufferedInputStream bs = new BufferedInputStream(in);
Thread.sleep(10000);
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(new File("D:\\aa.jpg")));
byte[] b = new byte[1024];
int len = 0;
while ((len = bs.read(b)) != -1) {
bos.write(b, 0, len);
}
bos.flush();
bos.close();
bs.close();
in.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}