encontrar archivos en una carpeta usando Java

Question

Lo que necesito hacer si buscar en una carpeta decir C:\example

entonces necesito ir a través de cada archivo y comprobar para ver si coincide con unos caracteres de inicio por lo que si los archivos de inicio

temp****.txt 
tempONE.txt 
tempTWO.txt 

lo tanto, si el archivo comienza con la temperatura y tiene una extensión .txt me gustaría a continuación, poner ese nombre de archivo en un File file = new File("C:/example/temp***.txt); por lo que a continuación puede leer en el archivo, a continuación, el bucle tiene que pasar a la siguiente archivo a compruebe si se encuentra como se indica arriba.

Answer 1

Lo que quiere es File.listFiles(FileNameFilter filter).

Eso le dará una lista de los archivos en el directorio que desea que coincidan con un determinado filtro.

El código será similar a:

// your directory 
File f = new File("C:\\example"); 
File[] matchingFiles = f.listFiles(new FilenameFilter() { 
    public boolean accept(File dir, String name) { 
     return name.startsWith("temp") && name.endsWith("txt"); 
    } 
}); 

Answer 2

Tenga una mirada en java.io.File.list() y FilenameFilter.

Answer 3

Puede utilizar un FilenameFilter, así:

File dir = new File(directory); 

File[] matches = dir.listFiles(new FilenameFilter() 
{ 
    public boolean accept(File dir, String name) 
    { 
    return name.startsWith("temp") && name.endsWith(".txt"); 
    } 
}); 

Answer 4

Considere Apache Commons IO, tiene una clase llamada FileUtils que tiene un método listFiles que podría ser muy útil en su caso.

Answer 5

Appache Commons IO varios

FilenameUtils.wildcardMatch

javadoc Ver Apache here. Coincide con el comodín con el nombre de archivo. Entonces puedes usar este método para tus comparaciones.

Answer 6

Para enumerar los archivos Json de su directorio determinado.

import java.io.File; 
    import java.io.FilenameFilter; 

    public class ListOutFilesInDir { 
     public static void main(String[] args) throws Exception { 

      File[] fileList = getFileList("directory path"); 

      for(File file : fileList) { 
       System.out.println(file.getName()); 
      } 
     } 

     private static File[] getFileList(String dirPath) { 
      File dir = new File(dirPath); 

      File[] fileList = dir.listFiles(new FilenameFilter() { 
       public boolean accept(File dir, String name) { 
        return name.endsWith(".json"); 
       } 
      }); 
      return fileList; 
     } 
    } 

Answer 7

Como dijo @Clarke, puede utilizar java.io.FilenameFilter para filtrar el archivo de condición específica.

Como complemento, me gustaría mostrar cómo usar java.io.FilenameFilter para buscar archivos en el directorio actual y su subdirectorio.

Los métodos comunes getTargetFiles y printFiles se utilizan para buscar archivos e imprimirlos.

public class SearchFiles { 

    //It's used in dfs 
    private Map<String, Boolean> map = new HashMap<String, Boolean>(); 

    private File root; 

    public SearchFiles(File root){ 
     this.root = root; 
    } 

    /** 
    * List eligible files on current path 
    * @param directory 
    *  The directory to be searched 
    * @return 
    *  Eligible files 
    */ 
    private String[] getTargetFiles(File directory){ 
     if(directory == null){ 
      return null; 
     } 

     String[] files = directory.list(new FilenameFilter(){ 

      @Override 
      public boolean accept(File dir, String name) { 
       // TODO Auto-generated method stub 
       return name.startsWith("Temp") && name.endsWith(".txt"); 
      } 

     }); 

     return files; 
    } 

    /** 
    * Print all eligible files 
    */ 
    private void printFiles(String[] targets){ 
     for(String target: targets){ 
      System.out.println(target); 
     } 
    } 
} 

voy a una demostración de cómo utilizar recursiva, BFS y DFS a hacer el trabajo.

recursiva:

/** 
* How many files in the parent directory and its subdirectory <br> 
* depends on how many files in each subdirectory and their subdirectory 
*/ 
private void recursive(File path){ 

    printFiles(getTargetFiles(path)); 
    for(File file: path.listFiles()){ 
     if(file.isDirectory()){ 
      recursive(file); 
     } 
    } 
    if(path.isDirectory()){ 
     printFiles(getTargetFiles(path)); 
    } 
} 

public static void main(String args[]){ 
    SearchFiles searcher = new SearchFiles(new File("C:\\example")); 
    searcher.recursive(searcher.root); 
} 

búsqueda en anchura:

/** 
* Search the node's neighbors firstly before moving to the next level neighbors 
*/ 
private void bfs(){ 
    if(root == null){ 
     return; 
    } 

    Queue<File> queue = new LinkedList<File>(); 
    queue.add(root); 

    while(!queue.isEmpty()){ 
     File node = queue.remove(); 
     printFiles(getTargetFiles(node)); 
     File[] childs = node.listFiles(new FileFilter(){ 

      @Override 
      public boolean accept(File pathname) { 
       // TODO Auto-generated method stub 
       if(pathname.isDirectory()) 
        return true; 

       return false; 
      } 

     }); 

     if(childs != null){ 
      for(File child: childs){ 
       queue.add(child); 
      } 
     } 
    } 
} 

public static void main(String args[]){ 
    SearchFiles searcher = new SearchFiles(new File("C:\\example")); 
    searcher.bfs(); 
} 

primera búsqueda en profundidad:

/** * Buscar medida de lo posible a lo largo de cada uno rama bef mineral de dar marcha atrás */ DFS private void() {

if(root == null){ 
     return; 
    } 

    Stack<File> stack = new Stack<File>(); 
    stack.push(root); 
    map.put(root.getAbsolutePath(), true); 
    while(!stack.isEmpty()){ 
     File node = stack.peek(); 
     File child = getUnvisitedChild(node); 

     if(child != null){ 
      stack.push(child); 
      printFiles(getTargetFiles(child)); 
      map.put(child.getAbsolutePath(), true); 
     }else{ 
      stack.pop(); 
     } 

    } 
} 

/** 
* Get unvisited node of the node 
* 
*/ 
private File getUnvisitedChild(File node){ 

    File[] childs = node.listFiles(new FileFilter(){ 

     @Override 
     public boolean accept(File pathname) { 
      // TODO Auto-generated method stub 
      if(pathname.isDirectory()) 
       return true; 

      return false; 
     } 

    }); 

    if(childs == null){ 
     return null; 
    } 

    for(File child: childs){ 

     if(map.containsKey(child.getAbsolutePath()) == false){ 
      map.put(child.getAbsolutePath(), false); 
     } 

     if(map.get(child.getAbsolutePath()) == false){ 
      return child; 
     } 
    } 

    return null; 
} 

public static void main(String args[]){ 
    SearchFiles searcher = new SearchFiles(new File("C:\\example")); 
    searcher.dfs(); 
} 

Answer 8

que sé, esta es una cuestión de edad. Pero solo por el bien de la compleción, la versión lambda.

File dir = new File(directory); 
File[] files = dir.listFiles((dir1, name) -> name.startsWith("temp") && name.endsWith(".txt"));