Búsqueda de ficheros

De ChuWiki
Saltar a: navegación, buscar

Búsqueda de ficheros

La siguiente clase tiene un método estático que permite buscar ficheros que cumplan un determinado patrón a partir de un directorio inicial, de forma recursiva o no.

/**
 * Javier Abellán, 11 Mayo 2006
 * 
 * Buscador de ficheros.
 */
package chuidiang.ficheros;

import java.io.File;
import java.util.LinkedList;
import java.util.regex.Pattern;

/**
 * Se le pasa una máscara de nombre de ficheros en formato regex de java
 * y busca, recursivamente o no, todos los ficheros que cumplen dicha máscara.
 * 
 * @author Chuidiang
 */
public class BuscadorDeFicheros
{
    /**
     * Busca todos los ficheros que cumplen la máscara que se le pasa y los
     * mete en la listaFicheros que se le pasa.
     * 
     * @param pathInicial Path inicial de búsqueda. Debe ser un directorio que
     * exista y con permisos de lectura.
     * @param mascara Una máscara válida para la clase Pattern de java.
     * @param listaFicheros Una lista de ficheros a la que se añadirán los File
     * que cumplan la máscara. No puede ser null. El método no la vacía.
     * @param busquedaRecursiva Si la búsqueda debe ser recursiva en todos los
     * subdirectorios por debajo del pathInicial.
     */
    public static void dameFicheros(String pathInicial, String mascara,
            LinkedList<File> listaFicheros, boolean busquedaRecursiva)
    {
        File directorioInicial = new File(pathInicial);
        if (directorioInicial.isDirectory())
        {
            File[] ficheros = directorioInicial.listFiles();
            for (int i = 0; i < ficheros.length; i++)
            {
                if (ficheros[i].isDirectory() && busquedaRecursiva)
                    dameFicheros(ficheros[i].getAbsolutePath(), mascara,
                            listaFicheros, busquedaRecursiva);
                else if (Pattern.matches(mascara, ficheros[i].getName()))
                    listaFicheros.add(ficheros[i]);
            }
        }
    }

    /**
     * Se le pasa una máscara de fichero típica de ficheros con * e ? y
     * devuelve la cadena regex que entiende la clase Pattern.
     * @param mascara Un String que no sea null.
     * @return Una máscara regex válida para Pattern.
     */
    public static String dameRegex(String mascara)
    {
        mascara = mascara.replace(".", "\\.");
        mascara = mascara.replace("*", ".*");
        mascara = mascara.replace("?",".");
        return mascara;
    }

    /**
     * Main de prueba.
     * @param args
     */
    /*
    public static void main(String[] args)
    {
        LinkedList<File> ficherosJava = new LinkedList<File>();
        dameFicheros("d:/users/usuario/un_directorio",
                dameRegex("*.java"), ficherosJava, true);
        for (int i = 0; i < ficherosJava.size(); i++)
            System.out.println(ficherosJava.get(i).getAbsolutePath());
    }
    */
}

Se utiliza llamando al método BuscadorDeFicheros.dameFicheros(). A este método se le pasa:

  • Un String con el path inicial de búsqueda. Debe ser un directorio con permisos de lectura.
  • Una máscara válida para la clase Pattern. Buscará ficheros que cumplan esta máscara. No devuelve directorios.
  • Una lista de File en la que se meterán los File que cumplan la máscara.
  • Si la búsqueda debe o no ser recursiva.

Si deseamos usar una máscara normal para ficheros de * e ? en vez de una máscara válida para Pattern, podemos llamar previamente al método dameRegex() para obtener la máscara de Pattern a partir de la máscara normal de ficheros.

El main comentado busca a partir de un directorio todos los ficheros *.java

Enlaces relacionados