Java 查找目录下继承了某类的所有文件

素颜马尾好姑娘i 2024-04-18 05:50 65阅读 0赞

package com.cdsn.sell;
    
    import java.nio.charset.StandardCharsets;
    import java.util.HashMap;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * java 查询文件夹下所有继承
     *
     * @author chenhao
     * @version 1.0.0
     * @since 1.0.0
     *
     * Created at 2019-09-03 09:19
     */
    public class FileRead {
    
      // 指定目录
      private static final String searchPath = "/Users/chenhao/Downloads/fpm_main";
      // 指定继承的类
      private static final String extName = "CMISOperation";
    
      // 是否是第一次遍历，查询的是一级继承关系
      private static boolean isOne = true;
      // 记录符合条件文件名，文件地址
      private static Map<String, String> map = new HashMap<>();
    
      // 记录有可能存在多次继承关系的类
      private static List<String> extList = new ArrayList<>();
      private static List<String> secondList = new ArrayList<>();
    
      public static void main(String[] args) throws IOException {
        // 1、先找到直接继承的类
        recursiveFiles(searchPath);
    
        // 2、 再去找间接继承
        isOne = false;
    
        while (!extList.isEmpty()) {
          recursiveFiles(searchPath);
          extList.clear();
          extList.addAll(secondList);
          secondList.clear();
        }
    
        // 输出最终结果
        printResult();
      }
    
    
      private static void recursiveFiles(String path) throws IOException {
        File file = new File(path);
    
        File[] files = file.listFiles();
        // 目录下文件
        assert files != null;
        if (files.length == 0) {
          System.out.println(path + "该文件夹下没有文件");
        }
    
        // 存在文件 遍历 判断
        for (File f : files) {
    
          // 判断是否为 文件夹
          if (f.isDirectory()) {
    
    //        System.out.print("文件夹: ");
    //        System.out.println(f.getAbsolutePath());
    
            // 为 文件夹继续遍历
            recursiveFiles(f.getAbsolutePath());
    
            // 判断是否为 文件
          } else if (f.isFile()) {
    
    //        System.out.print("文件: ");
    //        System.out.println(f.getAbsolutePath());
            // 读取文件内容
    
            fileRead(f);
    
          } else {
            System.out.print("未知错误文件");
          }
    
        }
      }
    
      /**
       * 判断该类是否符合标准
       */
      private static void fileRead(File f) throws IOException {
    
        InputStreamReader is = new InputStreamReader(new FileInputStream(f), StandardCharsets.UTF_8);
        BufferedReader br = new BufferedReader(is);
        String line;
        while ((line = br.readLine()) != null) {
          // 该类存在继承关系
    //      line.trim();
    //      line.replaceAll("\\s*", "");
          if (line.contains("class") && line.contains("extends")) {
            getResult(f, line);
    
          }
    
        }
      }
    
      private static void getResult(File f, String line) {
        // 单继承
        // 这个类有继承关系,那么判断。要么符合，要么继续递归检查最底层继承的谁
        // 取出继承的类名
        String extendsName;
        String[] split = line.split("\\s");
        int x = getIndex(split);
        extendsName = split[x + 1];
        if (isOne) {
    
          if (extendsName.contains(FileRead.extName)) {
            // ==满足条件
            map.put(f.getName(), f.getPath());
            extList.add(f.getName());
          }
        } else {
          for (String s : extList) {
            String targetName = s.replaceAll(".java", "");
            // 如果这个类继承了  已经继承基类的类，那么也符合标准
            if (extendsName.contains(targetName)) {
              map.put(f.getName(), f.getPath());
              secondList.add(f.getName());
            }
          }
    
        }
      }
    
      /*
       * 需求：查找指定数据在数组中第一次出现的索引
       */
      private static int getIndex(String[] arr) {
        //遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较
        for (int x = 0; x < arr.length; x++) {
          if (arr[x].equals("extends")) {
    
            //如果相等，就返回当前的索引值。
            return x;
          }
        }
        return -1;
      }
    
      private static void printResult() {
        System.out.println("================");
        // 遍历结果map
        Set<String> strings = map.keySet();
        for (String string : strings) {
          System.out.println(string + "::::" + map.get(string));
    
        }
    
        System.out.println("一共有 " + map.size() + " 条满足！");
      }
    }