Java文件内容查找与替换：基础I/O实现及常见陷阱规避

// ...
static void modifyFile(String oldfile, String newfile, String oldString, String newString)
{
    File fileToBeModified = new File("modify.txt"); // 问题1：硬编码了文件路径，忽略了newfile参数
    String oldContent = "";         
    BufferedReader reader = null;         
    FileWriter writer = null;

    try
    {
        reader = new BufferedReader(new FileReader(fileToBeModified)); // 问题2：从硬编码的文件读取
        // ... 省略读取内容到oldContent

        String newContent = oldContent.replaceAll(oldString, newString); // 执行替换

        writer = new FileWriter(fileToBeModified,true); // 问题3：以追加模式写入硬编码的文件，而不是newfile
        writer.write(newContent);
    }
    // ...
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FileContentReplacer {

    public static void main(String[] args) {
        // 创建一个测试文件
        createTestFile("test.txt", "This is a test file. Hit the road, Jack. What a hit! Another hit.");

        // 执行文件内容替换
        modifyFile("test.txt", "modified_test.txt", "Hit", "Cab");
        System.out.println("文件内容替换完成。请检查 modified_test.txt 文件。");

        // 验证替换结果（可选）
        try (BufferedReader reader = new BufferedReader(new FileReader("modified_test.txt"))) {
            String line;
            System.out.println("\n--- modified_test.txt 内容 ---");
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            System.out.println("-----------------------------");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 在源文件中查找指定字符串并替换为新字符串，然后写入目标文件。
     * 同时，尝试保持新字符串首字母的大小写与源文件中匹配字符串的首字母一致。
     *
     * @param oldFilePath 源文件路径
     * @param newFilePath 目标文件路径
     * @param oldString   待查找的旧字符串
     * @param newString   用于替换的新字符串
     */
    static void modifyFile(String oldFilePath, String newFilePath, String oldString, String newString) {
        File oldFile = new File(oldFilePath);
        File newFile = new File(newFilePath);

        StringBuilder contentBuilder = new StringBuilder();
        BufferedReader reader = null;
        FileWriter writer = null;

        try {
            // 1. 读取源文件内容
            reader = new BufferedReader(new FileReader(oldFile));
            String line;
            while ((line = reader.readLine()) != null) {
                contentBuilder.append(line).append(System.lineSeparator());
            }

            // 移除最后一个换行符，避免多余空行
            if (contentBuilder.length() > 0) {
                contentBuilder.setLength(contentBuilder.length() - System.lineSeparator().length());
            }

            String oldContent = contentBuilder.toString();

            // 2. 执行文本替换，并处理首字母大小写
            // 使用Pattern和Matcher进行大小写不敏感的查找和动态替换
            Pattern pattern = Pattern.compile(Pattern.quote(oldString), Pattern.CASE_INSENSITIVE);
            Matcher matcher = pattern.matcher(oldContent);
            StringBuffer resultBuffer = new StringBuffer(); // 使用StringBuffer来构建替换后的内容

            while (matcher.find()) {
                String foundWord = matcher.group(); // 获取实际匹配到的字符串
                String replacement = newString;

                // 根据匹配到的字符串的首字母大小写，调整替换字符串的首字母
                if (!newString.isEmpty() && !foundWord.isEmpty()) {
                    char firstCharFound = foundWord.charAt(0);
                    char firstCharNew = newString.charAt(0);

                    if (Character.isUpperCase(firstCharFound) && Character.isLowerCase(firstCharNew)) {
                        replacement = Character.toUpperCase(firstCharNew) + newString.substring(1);
                    } else if (Character.isLowerCase(firstCharFound) && Character.isUpperCase(firstCharNew)) {
                        replacement = Character.toLowerCase(firstCharNew) + newString.substring(1);
                    }
                    // 其他情况（如都大写、都小写、或新字符串为空），保持原样
                }

                // 使用 Matcher.quoteReplacement 来处理替换字符串中的特殊字符，避免被解释为正则表达式
                matcher.appendReplacement(resultBuffer, Matcher.quoteReplacement(replacement));
            }
            matcher.appendTail(resultBuffer); // 将剩余的非匹配部分追加到结果中

            String newContent = resultBuffer.toString();

            // 3. 写入目标文件
            writer = new FileWriter(newFile, false); // false表示覆盖模式
            writer.write(newContent);

        } catch (IOException e) {
            System.err.println("文件操作失败：" + e.getMessage());
            e.printStackTrace();
        } finally {
            // 4. 资源管理：确保关闭所有文件流
            try {
                if (reader != null) {
                    reader.close();
                }
                if (writer != null) {
                    writer.close();
                }
            } catch (IOException e) {
                System.err.println("关闭文件流失败：" + e.getMessage());
                e.printStackTrace();
            }
        }
    }

    // 辅助方法：创建测试文件
    private static void createTestFile(String fileName, String content) {
        try (FileWriter fw = new FileWriter(fileName)) {
            fw.write(content);
        } catch (IOException e) {
            System.err.println("创建测试文件失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}