Recherche de fichier récursivement

Question

J'essaie de trouver un fichier dans un répertoire racine et ses sous-répertoires.

Etape 1: recherchez un répertoire dans un chemin spécifié. Etape 2 - Si le répertoire ci-dessus est trouvé, cherchez un fichier dans l'un de ses sous-répertoires. Pour cela, j'utilise l'extrait de code ci-dessous qui recherche récursivement .. Maintenant, le problème ici est, comment puis-je sortir de la récursivité quand il répond à mes deux exigences ci-dessus ..?

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; 
} 

Merci, 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 

Maintenant, passer "test2.adv" en tant que troisième param lorsque vous invoquez FindFile. C'est plus intéressant que de le coder en dur.

Veuillez également noter que plusieurs fichiers pourraient correspondre à votre recherche, cette fonction ne la gère pas bien, elle renverra la première trouvée.

Answer 2

J'ai pris une approche légèrement différente pour résoudre ce problème en utilisant un FileFilter et une méthode différente pour la recherche récursive. Dans mon cas était à la recherche de n'importe quel fichier avec une extension ". JSON" où le cas du nom de fichier n'a pas d'importance.

Première, créer une classe d'implémentation FileFilter pour contenir le nom de fichier et effectuer la recherche récursive

/** 
* 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; 
    } 
} 

Ensuite, l'utilisation est assez simple:

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