Ajuda com codigo recursivo

Ola,

Por favor, vejam o codigo abaixo e, se puderem, ajudem me com os seguintes problemas:

- Primeiro e mais importante: Na classe de filtro eu estou aceitando todos os diretorios, pois se nao fizer isso nao consigo fazer a recursividade em seus subdiretorios (onde podem existir arquivos que interessem na busca). Com isso eu teria que colocar um outro filtro no metodo de callback e aplicar o filtro novamente, mas agora, apenas nos diretorios. Acho isso um "workaround" bem feio...rs. (Nao que o codigo esteja bonito, ate porque ainda eh um rascunho).

public void onDirectory(final File f)
    //Devo filtrar todos os diretorios aqui? Nao tem solucao melhor?
)

- Segundo (nao sei se eh mesmo um problema) dentro do metodo recursivo eu tenho a chamada de metodo:

onFile(f);

Pelos poucos testes que fiz, nao vi nenhum problema com isso, pois sempre eu comeco a busca a partir de um diretorio e NUNCA por um arquivo, entao eu acho que nunca terei um falso positivo. Os testes que fiz foram OK, mas como recursividade pode ser um pouco confuso as vezes, queria saber o que voces acham.

- Terceiro problema, embora nao muito importante nesse momento: Sei que recursividade nao oferece uma performance otima, no entanto gosto de sua elegancia. A pergunta eh: Existe, para esse problema especifico, algum enfoque diferente que traga mais performance e ainda assim ofereca um codigo elegante e simples?

Qualquer outra dica sera muito apreciada.

Obrigado

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication4;
 
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.regex.Pattern;
 
public class Main {
 
    /**
     * @param args the command line arguments
     */
    static FileTraversal f = null;
    static int countFile = 0;
    static int countDir = 0;
 
    public static void main(String[] args) throws IOException {
 
        new FileTraversal() {
 
            public void onFile(final File f) {
                countFile++;
                System.out.println("File: " + f.getAbsolutePath());
            }
 
            public void onDirectory(final File f) {
                countDir++;
                System.out.println("Directory: " + f.getAbsolutePath());
            }
        }.traverse(new File("/"));
 
        System.out.println("Total: " + countFile + " -> " + countDir + " = " + (countFile + countDir));
    }
 
    public static class FileTraversal {
 
        public final void traverse(final File f) throws IOException {
            if (f.isDirectory()) {
                onDirectory(f);
                FileFilter filter = new RegExpFilter(wildcardToRegex("pa*.txt"));
                final File[] childs = f.listFiles(filter);
                if (childs != null) {
                    for (File child : childs) {
                        traverse(child);
                    }
                }
                return;
            }
           ***onFile(f);***//What's the more elegant approach to solve that problem? 
        }
 
        public static String wildcardToRegex(String wildcard) {
            StringBuffer s = new StringBuffer(wildcard.length());
            s.append('^');
            for (int i = 0, is = wildcard.length(); i < is; i++) {
                char c = wildcard.charAt(i);
                switch (c) {
                    case '*':
                        s.append(".*");
                        break;
                    case '?':
                        s.append(".");
                        break;
                    // escape special regexp-characters
                    case '(':
                    case ')':
                    case '[':
                    case ']':
                    case '$':
                    case '^':
                    case '.':
                    case '{':
                    case '}':
                    case '|':
                    case '\\':
                        s.append("\\");
                        s.append(c);
                        break;
                    default:
                        s.append(c);
                        break;
                }
            }
            s.append('$');
            return (s.toString());
        }
 
        public void onDirectory(final File d) {
        }
 
        public void onFile(final File f) {
        }
    }
}
 
class RegExpFilter implements FileFilter {
 
    private Pattern pattern;
 
    public RegExpFilter(String regex) {
        pattern = Pattern.compile(regex);
    }
 
    public boolean accept(File pathname) {
     ***if (pathname.isDirectory()) //?????
        {
            return true;
        }***
        return pattern.matcher(pathname.getName()).matches();
    }
}

Topicos relacionados