Java 如何迭代文本文件中的路径列表

我有一个包含文件夹路径列表的文本文件

我想找出每个文件夹中有多少个带有特殊字符串（即任意字符串）的文件

对于一个路径，我可以列出文件夹中存在的所有文件，但我的问题是如何找到所有路径的文件

publicstaticvoidmain（字符串[]args）{
列表结果=新建ArrayList（）；
File[]fiels=新文件（“D:\\html”）.listFiles（）；
用于（文件：fiels）{
if（file.isFile（））{
add（file.getName（））；
}
}
系统输出打印项次（结果）；
}

提取当前代码，如果

文件是目录，则调用它

public static void main(String[] args) {

    List<String> result = new ArrayList<String>();

    File[] files = new File("D:\\html").listFiles();

    locateFiles(result, files);

    System.out.println(result);
}

private static void locateFiles(List<String> result, File[] files) {
    for (File file : files) {
        if (file.isFile()) {
            result.add(file.getName());
        } else if (file.isDirectory()) {
            locateFiles(result, file.listFiles());
        }
    }
}

publicstaticvoidmain（字符串[]args）{
列表结果=新建ArrayList（）；
File[]files=新文件（“D:\\html”）.listFiles（）；
定位文件（结果、文件）；
系统输出打印项次（结果）；
}
私有静态void locateFiles（列出结果，文件[]文件）{
用于（文件：文件）{
if（file.isFile（））{
add（file.getName（））；
}else if（file.isDirectory（））{
locateFiles（结果，file.listFiles（））；
}
}
}
因为程序在目录及其子目录上执行相同的功能集。使用递归解决问题是有意义的。在递归中，函数一次又一次地调用自己，直到它在给定的基本路径下处理所有目录和文件

static List<String> results = new ArrayList<String>();

public static void main(String[] args)  {
  listFiles(new File("D:\\html"));

  for (String result: results)
    System.out.println(result);
}
private static void listFiles(File dir) {
    //Get list of all files and folders in directory
    File[] files = dir.listFiles();

    //For all files and folders in directory
    for(File file: files){
        //Check if directory
        if(file.isDirectory())
            //Recursively call file list function on the new directory
            listFiles(file);
        else
           results.add(file.getAbsolutePath());        
    }        
}

static List results=new ArrayList（）；
公共静态void main（字符串[]args）{
列表文件（新文件（“D:\\html”）；
for（字符串结果：结果）
系统输出打印项次（结果）；
}
私有静态无效列表文件（文件目录）{
//获取目录中所有文件和文件夹的列表
File[]files=dir.listFiles（）；
//对于目录中的所有文件和文件夹
用于（文件：文件）{
//检查目录是否正确
if（file.isDirectory（））
//递归调用新目录上的文件列表函数
列表文件（文件）；
其他的
add（file.getAbsolutePath（））；
}        
}
我有一个
folderPath.txt
目录列表，如下所示

D:\305172

D:\部署

D:\HeapDumps

D:\程序文件

D:\编程

此代码为您提供了所需的内容+您可以根据需要进行修改

public class Main {

public static void main(String args[]) throws IOException {

    List<String> foldersPath = new ArrayList<String>();
    File folderPathFile = new File("C:\\Users\\ankur\\Desktop\\folderPath.txt");

    /**
     * Read the folderPath.txt and get all the path and store it into
     * foldersPath List
     */
    BufferedReader reader = new BufferedReader(new FileReader(folderPathFile));
    String line = reader.readLine();
    while(line != null){
        foldersPath.add(line);
        line = reader.readLine();
    }
    reader.close();

    /**
     * Map the path(i.e Folder) to the total no of 
     * files present in that path (i.e Folder)
     */
    Map<String, Integer> noOfFilesInFolder = new HashMap<String, Integer>();
    for (String pathOfFolder:foldersPath){
        File[] files2 = new File(pathOfFolder).listFiles();//get the arrays of files
        int totalfilesCount = files2.length;//get total no of files present
        noOfFilesInFolder.put(pathOfFolder,totalfilesCount);
    }

    System.out.println(noOfFilesInFolder);
}

}

公共类主{
公共静态void main（字符串args[]）引发IOException{
List foldersPath=new ArrayList（）；
File folderPath File=新文件（“C:\\Users\\ankur\\Desktop\\folderPath.txt”）；
/**
*读取folderPath.txt，获取所有路径并将其存储到
*文件夹列表
*/
BufferedReader reader=新的BufferedReader（新文件读取器（folderPathFile））；
字符串行=reader.readLine（）；
while（行！=null）{
折页页添加（行）；
line=reader.readLine（）；
}
reader.close（）；
/**
*将路径（即文件夹）映射到
*存在于该路径（即文件夹）中的文件
*/
Map noOfFilesInFolder=newhashmap（）；
用于（字符串pathfolder:foldersPath）{
File[]files2=新文件（pathfolder）.listFiles（）；//获取文件数组
int totalfilescont=files2.length；//获取存在的文件总数
noOfFilesInFolder.put（pathfolder，totalfilescont）；
}
System.out.println（noOfFilesInFolder）；
}
}

输出：

{D:\Program Files=1，D:\HeapDumps=16，D:\Deployment=48，D:\305172=4，D:\Programming=13}
文件中的路径是如何存储的？它们是纯文本吗？它们都在各自的行上吗？只需像现在这样做，在其周围环绕一个循环，在读取路径数组上进行迭代即可？