ToB企服应用市场:ToB评测及商务社交产业平台

标题: 除了递归算法,要如何优化实现文件搜索功能 [打印本页]

作者: 伤心客    时间: 2024-9-24 10:37
标题: 除了递归算法,要如何优化实现文件搜索功能
各人好,我是 V 哥,本日的文章来聊一聊 Java实现文件搜索功能,并且比较递归算法、迭代方式和Memoization技术的优缺点。
以下是一个利用 Java 实现的文件搜索功能,它会在指定目录及其子目录中搜索包罗特定关键字的文件。此实现利用递归方式遍历目录,并可以利用文件名或内容搜索文件。
利用递归搜索文件
  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.util.Scanner;
  4. public class FileSearcher {
  5.     // 在指定目录中搜索包含关键字的文件
  6.     public static void searchFiles(File directory, String keyword) {
  7.         // 获取目录下的所有文件和子目录
  8.         File[] files = directory.listFiles();
  9.         if (files == null) {
  10.             System.out.println("目录不存在或无法读取:" + directory.getAbsolutePath());
  11.             return;
  12.         }
  13.         // 遍历文件和子目录
  14.         for (File file : files) {
  15.             if (file.isDirectory()) {
  16.                 // 如果是目录,递归搜索
  17.                 searchFiles(file, keyword);
  18.             } else {
  19.                 // 如果是文件,检查文件名或文件内容是否包含关键字
  20.                 if (file.getName().contains(keyword)) {
  21.                     System.out.println("找到匹配文件(文件名): " + file.getAbsolutePath());
  22.                 } else if (containsKeyword(file, keyword)) {
  23.                     System.out.println("找到匹配文件(文件内容): " + file.getAbsolutePath());
  24.                 }
  25.             }
  26.         }
  27.     }
  28.     // 检查文件内容是否包含关键字
  29.     private static boolean containsKeyword(File file, String keyword) {
  30.         try (Scanner scanner = new Scanner(file)) {
  31.             // 逐行读取文件内容并检查是否包含关键字
  32.             while (scanner.hasNextLine()) {
  33.                 String line = scanner.nextLine();
  34.                 if (line.contains(keyword)) {
  35.                     return true;
  36.                 }
  37.             }
  38.         } catch (FileNotFoundException e) {
  39.             System.out.println("无法读取文件:" + file.getAbsolutePath());
  40.         }
  41.         return false;
  42.     }
  43.     public static void main(String[] args) {
  44.         // 指定搜索的目录和关键字
  45.         String directoryPath = "C:/java"; // 替换为实际目录路径
  46.         String keyword = "vg"; // 替换为实际关键字
  47.         // 创建文件对象表示目录
  48.         File directory = new File(directoryPath);
  49.         // 开始搜索
  50.         searchFiles(directory, keyword);
  51.     }
  52. }
复制代码
关键方法说明一下

利用说明

注意喽

题目来了,如果文件层次非常深的目录结构,需要怎么优化?
对于非常深的目录结构,利用递归搜索文件可能会导致栈溢出题目,因为每次递归调用都会斲丧栈空间。要优化这种情况下的文件搜索,可以利用迭代的方式来替代递归,从而避免栈溢出风险。迭代方式通常利用一个队列来模拟递归的过程,这样可以处理任意深度的目录结构。
以下是优化后的 Java 文件搜索实现,利用迭代方式遍历深层次的目录结构:
利用迭代方式搜索文件
  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.util.LinkedList;
  4. import java.util.Queue;
  5. import java.util.Scanner;
  6. public class FileSearcherIterative {
  7.     // 使用迭代方式搜索包含关键字的文件
  8.     public static void searchFiles(File rootDirectory, String keyword) {
  9.         // 使用队列来进行广度优先搜索
  10.         Queue<File> queue = new LinkedList<>();
  11.         queue.add(rootDirectory);
  12.         while (!queue.isEmpty()) {
  13.             // 取出队列头部的文件/目录
  14.             File current = queue.poll();
  15.             // 如果是目录,添加子文件和子目录到队列中
  16.             if (current.isDirectory()) {
  17.                 File[] files = current.listFiles();
  18.                 // 如果目录无法读取,跳过
  19.                 if (files == null) {
  20.                     System.out.println("无法读取目录:" + current.getAbsolutePath());
  21.                     continue;
  22.                 }
  23.                 for (File file : files) {
  24.                     queue.add(file);
  25.                 }
  26.             } else {
  27.                 // 如果是文件,检查文件名或文件内容是否包含关键字
  28.                 if (current.getName().contains(keyword)) {
  29.                     System.out.println("找到匹配文件(文件名): " + current.getAbsolutePath());
  30.                 } else if (containsKeyword(current, keyword)) {
  31.                     System.out.println("找到匹配文件(文件内容): " + current.getAbsolutePath());
  32.                 }
  33.             }
  34.         }
  35.     }
  36.     // 检查文件内容是否包含关键字
  37.     private static boolean containsKeyword(File file, String keyword) {
  38.         try (Scanner scanner = new Scanner(file)) {
  39.             // 逐行读取文件内容并检查是否包含关键字
  40.             while (scanner.hasNextLine()) {
  41.                 String line = scanner.nextLine();
  42.                 if (line.contains(keyword)) {
  43.                     return true;
  44.                 }
  45.             }
  46.         } catch (FileNotFoundException e) {
  47.             System.out.println("无法读取文件:" + file.getAbsolutePath());
  48.         }
  49.         return false;
  50.     }
  51.     public static void main(String[] args) {
  52.         // 指定搜索的目录和关键字
  53.         String directoryPath = "C:/java"; // 替换为实际目录路径
  54.         String keyword = "vg"; // 替换为实际关键字
  55.         // 创建文件对象表示目录
  56.         File rootDirectory = new File(directoryPath);
  57.         // 开始搜索
  58.         searchFiles(rootDirectory, keyword);
  59.     }
  60. }
复制代码
代码说明

优化要点

注意一下

来,我们继承优化。
如果文件或目录中存在符号链接(软链接)或循环引用的文件系统,会导致重复访问雷同文件或目录的情况,那要怎么办呢?
Memoization技术 闪亮登场
Memoization 技术介绍

Memoization 是一种用于优化递归算法的技术,它通过缓存函数的中心结果来避免重复盘算,从而进步性能。这个技术在盘算具有重叠子题目(overlapping subproblems)的递归算法时非常有用,如斐波那契数列、背包题目、动态规划等。
Memoization 的工作原理

利用 Memoization 技术优化深层次递归算法

以下是如何利用 Memoization 技术来优化 Java 中的深层次递归算法的示例。这里以斐波那契数列为例,首先展示一个未优化的递归实现,然后通过 Memoization 举行优化。
1. 未优化的递归算法

[code]public class FibonacciRecursive {    // 未利用 Memoization 的递归斐波那契算法    public static int fib(int n) {        if (n




欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4