Class Java

//package com.myapp.util.file;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
public class FileUtils {
    
    public Collection lookupClasspathFiles(String name) {
        Enumeration resources;
        List files = new ArrayList();
        
        try {
            resources = FileUtils.class.getClassLoader().getResources(name);
            
            while (resources.hasMoreElements()) {
                URI uri = resources.nextElement().toURI();
                File file = new File(uri);
                files.add(file);
            }
            
        } catch (Exception e) {
            throw new RuntimeException("could not lookup files with name: "+name, e);
        }
        
        return files;
    }
    
    public static class FileFileFilter implements FileFilter {
        @Override
        public boolean accept(File pathname) {
            return pathname.isFile();
        }
    }
    public static class DirectoryFileFilter implements FileFilter {
        @Override
        public boolean accept(File pathname) {
            return pathname.isDirectory();
        }
    }
    public static final class RecursiveFileIterator implements Iterator {
        private final List recursiveListing;
        private final int size;
        private int nextIndex = -1;
        public RecursiveFileIterator(File root,
                                     boolean includeDirs,
                                     boolean includeFiles) {
            List l = new ArrayList();
            traverse(root, includeDirs, includeFiles, l);
            recursiveListing = Collections.unmodifiableList(l);
            size = recursiveListing.size();
            if (size > 0) {
                nextIndex = 0;
            }
        }
        private List traverse(File startDir,
                                    final boolean includeDirs,
                                    final boolean includeFiles,
                                    List toAdd) {
            validateDirectory(startDir);
            File[] filesAndDirs = startDir.listFiles();
            Arrays.sort(filesAndDirs);
            File tmp = null;
            boolean isDir, isFile;
            for (int i = 0; i < filesAndDirs.length; i++) {
                tmp = filesAndDirs[i];
                isDir = tmp.isDirectory();
                isFile = tmp.isFile();
                if (isDir) {
                    if (includeDirs)
                        toAdd.add(tmp);
                    traverse(tmp, includeDirs, includeFiles, toAdd);
                } else if (isFile) {
                    if (includeFiles)
                        toAdd.add(tmp);
                }
            }
            return toAdd;
        }
        @Override
        public File next() {
            File next = recursiveListing.get(nextIndex);
            nextIndex++;
            return next;
        }
        @Override
        public boolean hasNext() {
            if (size < 0) {
                return false; // empty list
            }
            if (nextIndex >= size) {
                return false; // last element reached
            }
            return true;
        }
        @Override
        public void remove() {
            throw new RuntimeException("not supported yet");
        }
        /**
         * Directory is valid if it exists, does not represent a file, and can
         * be read.
         */
        private static void validateDirectory(File d) {
            if (d == null) {
                throw new IllegalArgumentException("Directory should not be null.");
            }
            if (!d.exists()) {
                throw new IllegalArgumentException("Directory does not exist: "
                                                   + d);
            }
            if (!d.isDirectory()) {
                throw new IllegalArgumentException("Is not a directory: " + d);
            }
            if (!d.canRead()) {
                throw new IllegalArgumentException("Directory cannot be read: "
                                                   + d);
            }
        }
    }
    private FileUtils() {
    }
    public static void deleteRecursively(File f) {
        if (!f.exists()) {
            return;
        }
        if (f.isDirectory()) {
            File[] children = f.listFiles();
            if (children != null) {
                for (int i = 0; i < children.length; i++) {
                    deleteRecursively(children[i]);
                }
            }
        }
        f.delete();
    }
}