Here you can find the source of zipDirectory(File p2BeZippedDir, File pZipFile)
public static void zipDirectory(File p2BeZippedDir, File pZipFile)
/**// w w w. ja v a 2 s .com Copyright 2014 Jens Glufke Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. * -----------------------------------------------------------------------<br> * * class that can be used to operations on files like copy, deleteDir etc */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileFilter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.Arrays; import java.util.Enumeration; import java.util.Vector; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.zip.ZipEntry; import java.util.zip.ZipException; import java.util.zip.ZipFile; import java.util.zip.ZipOutputStream; public class Main{ public static void zipDirectory(File p2BeZippedDir, File pZipFile) { if (p2BeZippedDir == null) { throw new IllegalArgumentException( "parameter p2BeZippedDir must not be null"); } if (!p2BeZippedDir.isDirectory()) { throw new IllegalArgumentException( "parameter p2BeZippedDir has to be a directory"); } if (pZipFile == null) { throw new IllegalArgumentException( "parameter pZipFile must not be null"); } if (pZipFile.isDirectory()) { throw new IllegalArgumentException( "parameter pZipFile has to be a file and not a directory"); } Vector<File> lFileList = find(p2BeZippedDir, ".+"); String lDirName = p2BeZippedDir.getAbsolutePath(); int lBegin = lDirName.length() + 1; String lEntryName = null; try { boolean lIsEntryWritten = false; pZipFile.delete(); FileOutputStream lFOS = new FileOutputStream(pZipFile); BufferedOutputStream lBOS = new BufferedOutputStream(lFOS); ZipOutputStream lZOS = new ZipOutputStream(lBOS); for (File lFile : lFileList) { if (lFile.isFile()) { lIsEntryWritten = true; lEntryName = lFile.getAbsolutePath(); lEntryName = "/" + lEntryName.substring(lBegin); lEntryName = lEntryName.replaceAll("\\\\", "/"); ZipEntry lZipEntry = new ZipEntry(lEntryName); lZOS.putNextEntry(lZipEntry); FileInputStream lFIS = new FileInputStream(lFile); BufferedInputStream lBIS = new BufferedInputStream(lFIS); copy(lBIS, lZOS); lZOS.closeEntry(); } } if (!lIsEntryWritten) { lZOS.putNextEntry(new ZipEntry("ZipFileIsEmpty")); lZOS.closeEntry(); } lZOS.close(); } catch (ZipException e) { throw new RuntimeException("could not zip entry:" + lEntryName, e); } catch (IOException e) { throw new RuntimeException(e); } } /** * * find a file in pDir and its sub directories that matches pFilter * @param pFoundFiles * @param pDir * @param pFilter * @return * */ public static Vector<File> find(Vector<File> pFoundFiles, File pDir, FileFilter pFilter) { if (pDir.isDirectory()) { File[] lFoundFiles = pDir.listFiles(pFilter); if (lFoundFiles != null && lFoundFiles.length > 0) { pFoundFiles.addAll(Arrays.asList(lFoundFiles)); } for (File lFile : pDir.listFiles()) { find(pFoundFiles, lFile, pFilter); } } return pFoundFiles; } /** * find all files in pDirectory and its sub directories whose absolute path * matches pRegex * @param pDirectory * @param pRegex * @return */ public static synchronized Vector<File> find(File pDirectory, String pRegex) { Vector<File> lReturn = new Vector<File>(); lReturn = find(lReturn, pDirectory, new RegExpFileFilter(pRegex)); return lReturn; } /** * * @param pSourceFile * @param pTargetFile * @throws IOException */ public static synchronized void copy(File pSourceFile, File pTargetFile) throws IOException { if (!pSourceFile.getCanonicalPath().equals( pTargetFile.getCanonicalPath())) { pTargetFile.getParentFile().mkdirs(); FileInputStream lFIS = new FileInputStream(pSourceFile); FileOutputStream lFOS = new FileOutputStream( pTargetFile.getCanonicalPath()); copy(lFIS, lFOS); lFOS.close(); } } /** * destination is not closed on exit of method ! * @param pSourceStream * @param pTargetStream * @throws IOException */ public static synchronized void copy(InputStream pSourceStream, OutputStream pTargetStream) throws IOException { copy(pSourceStream, pTargetStream, true); } /** * destination is not closed on exit of method ! * @param pSourceStream * @param pTargetStream * @param closeSource define if the source id closed after copying * @throws IOException */ public static synchronized void copy(InputStream pSourceStream, OutputStream pTargetStream, boolean closeSource) throws IOException { final int buffSize = 1024; final byte[] lBuf = new byte[buffSize]; int lBytesRead = 0; while ((lBytesRead = pSourceStream.read(lBuf, 0, buffSize)) != -1) { pTargetStream.write(lBuf, 0, lBytesRead); } if (closeSource) { pSourceStream.close(); } } /** * * @param pSourceFile * @param pTargetFile * @throws IOException */ public static synchronized void copy(String pSourceFile, String pTargetFile) throws IOException { copy(new File(pSourceFile), new File(pTargetFile)); } /** * * @param pFile * @return */ public static String getCanonicalPath(File pFile) { String lReturnPath = pFile.getAbsolutePath(); lReturnPath = lReturnPath.replaceAll("\\\\", "/"); final String regExp1 = "()[^/]+/(\\.\\.)"; final Pattern pattern1 = Pattern.compile(regExp1); final String regExp2 = "([^/]+/)(\\.)"; final Pattern pattern2 = Pattern.compile(regExp2); final String regExp3 = "(/)(/)"; final Pattern pattern3 = Pattern.compile(regExp3); for (Pattern lPattern : new Pattern[] { pattern1, pattern2, pattern3 }) { Matcher lMatcher = lPattern.matcher(lReturnPath); while (lMatcher.find()) { lReturnPath = lMatcher.replaceFirst(lMatcher.group(1)); lMatcher = lPattern.matcher(lReturnPath); } } if (lReturnPath.endsWith("/")) { lReturnPath = lReturnPath .substring(0, lReturnPath.length() - 1); } return lReturnPath; } }