在Java中利用命令行参数处理文件路径的健壮策略

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class FileReaderApp {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("请提供文件路径作为命令行参数。");
            return;
        }

        try {
            // 尝试使用命令行参数作为文件路径
            File inputFile = new File(args[0]);
            Scanner fileReader = new Scanner(inputFile);

            System.out.println("正在读取文件: " + inputFile.getAbsolutePath());
            while (fileReader.hasNextLine()) {
                String fileData = fileReader.nextLine();
                System.out.println(fileData);
            }
            fileReader.close();
        } catch (FileNotFoundException e) {
            System.err.println("错误：无法找到指定的文件。请检查文件路径或名称。");
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("发生未知错误：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

String userDir = System.getProperty("user.dir"); // 获取当前工作目录
File inputFile = new File(userDir + File.separator + args[0]);
// 或更安全地处理相对路径
// File inputFile = new File(userDir, args[0]); // 如果args[0]是相对路径

String customPath = System.getProperty("my.app.filePath");
File inputFile;
if (customPath != null) {
    inputFile = new File(customPath);
} else {
    // 回退到其他策略，或抛出异常
    inputFile = new File(args[0]); // 默认处理
}

String dataDirPath = System.getenv("MY_APP_DATA_DIR");
File inputFile;
if (dataDirPath != null) {
    inputFile = new File(dataDirPath, args[0]); // 结合环境变量和文件名
} else {
    System.err.println("环境变量 MY_APP_DATA_DIR 未设置，尝试默认路径。");
    inputFile = new File(args[0]);
}

import java.io.InputStream;
import java.util.Scanner;
import java.io.IOException;

public class ResourceReaderApp {
    public static void main(String[] args) {
        String resourceName = args.length > 0 ? args[0] : "super_simple.txt"; // 默认资源名

        // 使用当前类的类加载器获取资源
        // 注意：getResourceAsStream需要相对路径，相对于classpath根目录
        try (InputStream is = ResourceReaderApp.class.getClassLoader().getResourceAsStream(resourceName)) {
            if (is == null) {
                System.err.println("错误：无法找到资源文件: " + resourceName);
                return;
            }
            Scanner scanner = new Scanner(is);
            System.out.println("正在读取资源: " + resourceName);
            while (scanner.hasNextLine()) {
                System.out.println(scanner.nextLine());
            }
            scanner.close();
        } catch (IOException e) {
            System.err.println("读取资源时发生IO错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.concurrent.atomic.AtomicReference;

public class FileSearcher {

    public static Path findFile(String fileName, Path startDir) throws IOException {
        AtomicReference<Path> foundPath = new AtomicReference<>();
        Files.walkFileTree(startDir, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                if (file.getFileName().toString().equals(fileName)) {
                    foundPath.set(file);
                    return FileVisitResult.TERMINATE; // 找到即停止
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                // 可以添加逻辑跳过某些目录，例如隐藏目录
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) {
                // 处理访问文件失败的情况，例如权限问题
                System.err.println("访问文件失败: " + file + " - " + exc.getMessage());
                return FileVisitResult.CONTINUE;
            }
        });
        return foundPath.get();
    }

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("请提供要搜索的文件名。");
            return;
        }
        String fileNameToSearch = args[0];
        try {
            // 从用户主目录开始搜索
            Path startPath = Paths.get(System.getProperty("user.home"));
            Path foundFile = findFile(fileNameToSearch, startPath);

            if (foundFile != null) {
                System.out.println("找到文件: " + foundFile.toAbsolutePath());
                // 进一步处理文件，例如使用Scanner读取
                // ...
            } else {
                System.out.println("未找到文件: " + fileNameToSearch + " 在 " + startPath.toAbsolutePath() + " 及其子目录中。");
            }
        } catch (IOException e) {
            System.err.println("文件搜索过程中发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class OSCommandSearcher {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("请提供要搜索的文件名。");
            return;
        }
        String fileName = args[0];
        String os = System.getProperty("os.name").toLowerCase();
        String command;
        String[] commandArgs;

        if (os.contains("win")) {
            command = "cmd.exe";
            commandArgs = new String[]{"/c", "dir", "/s", "/b", fileName};
        } else { // Linux/macOS
            command = "find";
            // 假设从用户主目录开始搜索
            commandArgs = new String[]{System.getProperty("user.home"), "-name", fileName};
        }

        try {
            ProcessBuilder pb = new ProcessBuilder(command, commandArgs[0], commandArgs[1], commandArgs[2]);
            Process p = pb.start();

            BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            boolean found = false;
            while ((line = reader.readLine()) != null) {
                if (!line.trim().isEmpty()) {
                    System.out.println("找到文件: " + line);
                    found = true;
                    // 通常只取第一个找到的
                    break;
                }
            }
            p.waitFor(); // 等待进程结束

            if (!found) {
                System.out.println("未找到文件: " + fileName);
            }

        } catch (IOException | InterruptedException e) {
            System.err.println("执行搜索命令时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}