Como percorrer o conteúdo de uma pasta pegando os arquivos para zipá-los?!

File pasta = new File("caminho para a pasta");

File[] arquivos = pasta.listFiles();

for(int i = 0; i < arquivos.length; i++) {
   ...código...
}

package com.mti.backupFacil;

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.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

import org.apache.commons.logging.Log;

/**
 * @author <a href='mailto:[email removido]'>Rodrigo Mendonça</a>
 * 
 */

public abstract class BaseBackup {

	/**
	 * Log de realização de backup
	 */
	private Log log = null;

	/**
	 * Construtor padrão.
	 */
	public BaseBackup() {
	}

	/**
	 * Construtor com objeto para efetivação de logs.
	 * 
	 * @param pLog
	 */
	public BaseBackup(Log pLog) {
		log = pLog;
	}

	/**
	 * Cria uma estrutura de diretórios.
	 * 
	 * @param caminho
	 *            Estrutura a ser criada
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na criação dos diretórios
	 */
	protected void criarPastas(String caminho) throws BackupFacilException {
		debug("Inicio - criarPastas(" + caminho + ")");
		File pasta = new File(caminho);
		if (!pasta.exists()) {
			boolean success = (new File(caminho)).mkdir();
			if (!success) {
				success = (new File(caminho)).mkdirs();
			}
			if (!success) {
				error("criarPastas(" + caminho + ")");
				throw new BackupFacilException("Erro na criação do diretório ["
						+ caminho + "]");
			}
		}
		debug("Fim - criarPastas(" + caminho + ")");
	}

	/**
	 * Cria uma pasta.
	 * 
	 * @param caminhoPasta
	 *            Pasta a ser criada
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na criação da pasta
	 */
	protected void criarPasta(String caminhoPasta) throws BackupFacilException {
		debug("Inicio - criarPasta(" + caminhoPasta + ")");
		if (!(new File(caminhoPasta)).exists()) {
			boolean success = (new File(caminhoPasta)).mkdir();
			if (!success) {
				error("criarPasta(" + caminhoPasta + ")");
				throw new BackupFacilException("Erro na criação do diretório ["
						+ caminhoPasta + "]");
			}
		}
		debug("Fim - (" + caminhoPasta + ")");
	}

	/**
	 * Move uma pasta.
	 * 
	 * @param caminhoPasta
	 *            Caminho da pasta que será movida
	 * @param caminhoDestino
	 *            Caminho da pasta de destino
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na operação
	 */
	protected void moverPasta(String caminhoPasta, String caminhoDestino)
			throws BackupFacilException {

		debug("Inicio - moverPasta(" + caminhoPasta + ", " + caminhoDestino
				+ ")");

		File src = new File(caminhoPasta);
		File dst = new File(caminhoDestino);

		boolean success = src.renameTo(new File(dst, src.getName()));
		if (!success) {
			error("moverPasta(" + caminhoPasta + ", " + caminhoDestino + ")");
			throw new BackupFacilException("Erro na copia de [" + caminhoPasta
					+ "] para [" + caminhoDestino + "]");
		}

		debug("Fim - moverPasta(" + caminhoPasta + ", " + caminhoDestino + ")");
	}

	/**
	 * Copia um arquivo.
	 * 
	 * @param caminhoArquivo
	 *            Camnhio do arquivo a ser copiado
	 * @param destino
	 *            Camniho do arquivo de destino
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na cópia do arquivo.
	 */
	protected void copiarArquivo(String caminhoArquivo, String caminhoDestino)
			throws BackupFacilException {

		debug("Inicio - copiarArquivo(" + caminhoArquivo + ", "
				+ caminhoDestino + ")");

		File src = new File(caminhoArquivo);
		File dst = new File(caminhoDestino);

		InputStream in;
		OutputStream out;
		try {
			in = new FileInputStream(src);
			if (dst.isDirectory()) {
				out = new FileOutputStream(dst + "/" + src.getName());
			} else {
				out = new FileOutputStream(dst);
			}
			// Transfer bytes from in to out
			byte[] buf = new byte[1024];
			int len;
			while ((len = in.read(buf)) > 0) {
				out.write(buf, 0, len);
			}
			in.close();
			out.close();
		} catch (FileNotFoundException e) {
			error("copiarArquivo(" + caminhoArquivo + ", " + caminhoDestino
					+ ")");
			throw new BackupFacilException("Erro na copia de ["
					+ caminhoArquivo + "] para [" + caminhoDestino + "]", e);
		} catch (IOException e) {
			error("copiarArquivo(" + caminhoArquivo + ", " + caminhoDestino
					+ ")");
			throw new BackupFacilException("Erro na copia de ["
					+ caminhoArquivo + "] para [" + caminhoDestino + "]", e);
		}
		debug("Fim - copiarArquivo(" + caminhoArquivo + ", " + caminhoDestino
				+ ")");
	}

	/**
	 * Apaga uma pasta.
	 * 
	 * @param caminhoPasta
	 *            Caminho da pasta que será apagada
	 * @return true caso pasta apagada com sucesso
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na operação.
	 */
	protected boolean apagarPasta(String caminhoPasta)
			throws BackupFacilException {

		debug("Inicio - apagarPasta(" + caminhoPasta + ")");

		File dir = new File(caminhoPasta);
		if (dir.isDirectory()) {
			String[] children = dir.list();
			for (int i = 0; i < children.length; i++) {
				boolean success = apagarPasta(children[i]);
				if (!success) {
					error("apagarPasta(" + caminhoPasta + ")");
					throw new BackupFacilException("Erro ao apagar a pasta ["
							+ caminhoPasta + "]");
				}
			}
		}
		debug("Fim - apagarPasta(" + caminhoPasta + ")");
		return dir.delete();
	}

	/**
	 * Apaga um arquivo.
	 * 
	 * @param caminhoArquivo
	 *            Caminho do Arquivo a ser apagado
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na cópia do arquivo.
	 */
	protected void apagarArquivo(String caminhoArquivo)
			throws BackupFacilException {

		debug("Inicio - apagarArquivo(" + caminhoArquivo + ")");

		boolean success = (new File(caminhoArquivo)).delete();
		if (!success) {
			error("apagarArquivo(" + caminhoArquivo + ")");
			throw new BackupFacilException("Erro ao apagar o arquivo ["
					+ caminhoArquivo + "]");
		}
		debug("Fim - apagarArquivo(" + caminhoArquivo + ")");
	}

	/**
	 * Compacta uma pasta ou arquivo para um arquivo .ZIP.
	 * 
	 * @param caminhoFonte
	 *            Caminho da pasta ou arquivo que será compactado
	 * @param caminhoArquivoZip
	 *            Caminho do Arquivo zip de destino
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na compactação do arquivo
	 *             ou pasta.
	 */
	protected void compactarPastaToZip(String caminhoFonte,
			String caminhoArquivoZip) throws BackupFacilException {

		debug("Inicio - compactarPastaToZip(" + caminhoFonte + ", "
				+ caminhoArquivoZip + ")");

		File[] filenames = new File(caminhoFonte).listFiles();

		byte[] buf = new byte[1024];

		try {
			ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
					caminhoArquivoZip));

			// Compress the files
			for (int i = 0; i < filenames.length; i++) {
				FileInputStream in = new FileInputStream(filenames[i]
						.getAbsolutePath());

				// Add ZIP entry to output stream.
				out.putNextEntry(new ZipEntry(filenames[i].getName()));

				// Transfer bytes from the file to the ZIP file
				int len;
				while ((len = in.read(buf)) > 0) {
					out.write(buf, 0, len);
				}

				// Complete the entry
				out.closeEntry();
				in.close();
			}
			out.close();
		} catch (IOException e) {
			error("compactarPastaToZip(" + caminhoFonte + ", "
					+ caminhoArquivoZip + ")");
			throw new BackupFacilException("Erro ao compactar [" + caminhoFonte
					+ "] para [" + caminhoArquivoZip + "]", e);
		}
		debug("Fim - compactarPastaToZip(" + caminhoFonte + ", "
				+ caminhoArquivoZip + ")");
	}

	private void copyInputStream(InputStream in, OutputStream out)
			throws IOException {
		byte[] buffer = new byte[1024];
		int len;
		while ((len = in.read(buffer)) >= 0){
			out.write(buffer, 0, len);
		}

		in.close();
		out.close();
	}

	/**
	 * Descompacta um arquvo zip
	 * 
	 * @param caminhoFonte
	 *            Arquivo que será descompactado
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na operação.
	 */
	protected void descompactarZip(String caminhoFonte, String destino)
			throws BackupFacilException {

		debug("Inicio - descompactarZip(" + caminhoFonte + ", " + destino + ")");

		if("".equals(destino)){
			destino = (new File(caminhoFonte)).getParentFile().getAbsolutePath() + "/";
		}

		Enumeration entries;
		ZipFile zipFile;

		try {
			zipFile = new ZipFile(caminhoFonte);
			entries = zipFile.entries();

			while (entries.hasMoreElements()) {
				ZipEntry entry = (ZipEntry) entries.nextElement();
				if (entry.isDirectory()) {
					(new File(entry.getName())).mkdir();
					continue;
				}
				copyInputStream(zipFile.getInputStream(entry),
						new BufferedOutputStream(new FileOutputStream(destino + entry
								.getName())));
			}
			zipFile.close();
		} catch (IOException e) {
			error("descompactarZip(" + caminhoFonte + ")");
			throw new BackupFacilException("Erro ao descompactar o arquivo ["
					+ caminhoFonte + "]", e);
		}
		debug("Fim - descompactarZip(" + caminhoFonte + ")");
	}

	/**
	 * Move um arquivo.
	 * 
	 * @param caminhoArquivo
	 *            Caminho do arquivo que será movido
	 * @param caminhoDestino
	 *            Caminho de destino
	 * @throws BackupFacilException
	 *             Exceção lançada caso ocorra falha na operação
	 */
	protected void moverArquivo(String caminhoArquivo, String caminhoDestino)
			throws BackupFacilException {
		copiarArquivo(caminhoArquivo, caminhoDestino);
		apagarArquivo(caminhoArquivo);
	}

	/**
	 * Grava log de debug.
	 * 
	 * @param obj
	 *            Mensagem a ser gravada
	 */
	private void debug(Object obj) {
		if (log != null) {
			log.debug(obj);
		}
	}

	/**
	 * Grava log de erro.
	 * 
	 * @param obj
	 *            Mensagem a ser gravada
	 */
	private void error(Object obj) {
		if (log != null) {
			log.error(obj);
		}
	}
}

public class BackupFacilException extends Exception {
	
	private String message;
	
	BackupFacilException (String message)
	{
		this.message = message;
	}
	
	BackupFacilException (String message,IOException e)
	{
		this.message = message + e;
	}
	
	
	public String getMessage()
	{
		return message;
	}


}

package com.mti.backupFacil;

import java.io.IOException;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.PropertyConfigurator;

public class Teste2 {

	private static Log log = LogFactory.getLog(Teste.class);

	public static void main(String[] args) {
		
		Properties props = new Properties() ;
		try {
			//carrega arquivo de porperties do log
			props.load(Teste.class.getResourceAsStream("/conf/log4j.properties"));
		} catch (IOException e1) {
			e1.printStackTrace();
		} 

		PropertyConfigurator.configure(props);

		BackupMedia bkp = new BackupMedia(log);

		System.out.println("Begin..");
		
		try {
			bkp.compactarPastaToZip("c:\temp\musicas","c:\temp\bkmp3.zip");
		} catch (BackupFacilException e) {
			e.printStackTrace();
		}

		System.out.println("End!");
	}
}

log4j.rootLogger=DEBUG, A1
log4j.appender.A1=org.apache.log4j.FileAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.file=c:/logTesteAAA.log
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

// cria novo zip
				zipFile.createNewFile();
				ZipOutputStream stream = new ZipOutputStream(new FileOutputStream(zipFile));
				// máxima compactação
				stream.setLevel(9);
				for (Iterator iter = arquivos.iterator(); iter.hasNext();) {
					String caminhoArquivo = ((String) iter.next()).trim();
					// retira a possível "/" do começo do arquivo
					while (caminhoArquivo.startsWith("/")) {
						caminhoArquivo = caminhoArquivo.substring(1);
					}
					in = new File(dirRaiz, caminhoArquivo);
					// se existir o arquivo
					if (in.exists()) {
						// abre stream do arquivo de origem
						fileInputStream = new FileInputStream(in);
	// cria nova entrada no zip
						stream.putNextEntry(new ZipEntry(caminhoArquivo));
						// grava os bytes no zip
						while ((bytes = fileInputStream.available()) > 0) {
							byte[] buffer = new byte[bytes];
							fileInputStream.read(buffer);
							stream.write(buffer);
						}
						// fecha a stream de origem e a entrada do zip
						fileInputStream.close();
						stream.closeEntry();
					} else {
						// o arquivo passado não foi encontrado pelo programa
					}
				}
				// fecha o zip
				stream.close();

marshaller.marshal(aExpRas, (Result) new FileOutputStream(fileName) );