Búsqueda de archivos recursivamente

Question

Estoy tratando de encontrar un archivo en un directorio raíz y sus subdirectorios.

Paso1- Busque un directorio en una ruta especificada. Paso 2: si se encuentra el directorio anterior, busque un archivo en uno de sus subdirectorios.

Para esto, uso el siguiente fragmento de código que busca de forma recursiva. Ahora, el problema aquí es, ¿cómo puedo salir de la recursividad cuando cumple con mis dos requisitos anteriores?

boolean bFileFound = false; 
File fileFound  = null; 

private void findFile(File aFile, String sDir){ 

    String filePath = aFile.getAbsolutePath(); 

    if(aFile.isFile() && filePath.contains(sDir)){ 

       if(aFile.getName().contains("test2.adv")){ 
        Log.d(TAG, "[FILE] " + aFile.getName()); 
        fileFound = aFile; 
        bFileFound = true; 
       } 

      // return true; 
    }else if(aFile.isDirectory()){ 

     String sDirName = aFile.getName(); 
     Log.d(TAG, "[DIR] " + sDirName); 

     if(sDirName.contains(sDir)){ 

      Log.d(TAG, "Found the directory..& Absolute Path = " + aFile.getAbsolutePath()); 
      sDir = sDirName; 
     } 

     File[] listFiles = aFile.listFiles(); 

     if(listFiles != null){ 

      for(int i = 0; i < listFiles.length; i++){ 

       if(bFileFound) 
        return; 

      findFile(listFiles[ i ], sDir); 
      } 
     }else{ 

      Log.d(TAG, " [ACCESS DENIED]"); 
     } 
    } 

    // return null; 
} 

Gracias, DK

Answer 1

/** 
* Search file a file in a directory. Please comment more here, your method is not that standard. 
* @param file the file/folder where to look our file for. 
* @param sDir a directory that must be in the path of the file to find 
* @param toFind the name of file we are looking for. 
* @return the file we were looking for. Null if no such file could be found. 
*/ 
private File findFile(File aFile, String sDir, String toFind){ 
    if(aFile.isFile() && 
      aFile.getAbsolutePath().contains(sDir) && 
      aFile.getName().contains(toFind)) { 
         return aFile; 
     } else if(aFile.isDirectory()) { 
     for(File child : aFile.listFiles()){ 
      File found = findFile(child, sDir, toFind); 
        if(found != null) { 
         return found; 
        }//if 
     }//for 
    }//else 
    return null; 
}//met 

Ahora, pasar "test2.adv" como tercer parámetro cuando se invoca FindFile. Eso es más interesante que hardcoding.

También tenga en cuenta que varios archivos pueden coincidir con su búsqueda, esta función no lo maneja bien, devolverá la primera encontrada.

Answer 2

Tomé un enfoque ligeramente diferente para resolver este problema usando un FileFilter y un método diferente para buscar recursivamente. En mi caso, estaba buscando cualquier archivo con una extensión ".json" donde el nombre del archivo no importara.

Primera, crear una clase FileFilter aplicación para contener el nombre del archivo y realizar la búsqueda recursiva

/** 
* A {@link FileFilter} implementation that checks recursively files of a 
* specified fileName or extension string 
*/ 
public class FileExtensionFinder implements FileFilter { 
    private final String fileName; 
    private final List<File> foundFiles; 

    /** 
    * Constructor for FileExtensionFinder 
    * @param fileName string of the filename or extension being searched for 
    */ 
    public FileExtensionFinder(String fileName) { 
     this.fileName = fileName; 
     this.foundFiles = new ArrayList<>(); 
    } 

    @Override 
    public boolean accept(File pathname) { 
     // accept anything that is a folder or matches the fileName string 
     return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(fileName); 
    } 

    /** 
    * Searches recursively for all files with the provided filename/extension string 
    * @param filesArray an array of files (including folders) to iterate over 
    */ 
    public List<File> findFiles(File... filesArray) { 
     for (File file : filesArray) { 
      if (file.isDirectory()) { 
       findFiles(file.listFiles(this)); 
      } else if (file.getName().toLowerCase().endsWith(fileName)) { 
       foundFiles.add(file); 
      } 
     } 
     return foundFiles; 
    } 
} 

Entonces, el uso es bastante simple:

File fileLocation = // get your file here ... 
List<File> foundFiles = new FileExtensionFinder(".json").findFiles(fileLocation);