Java中实现文件内容追加与数据持久化的策略

FileWriter fWriter = new FileWriter("notes.data");

import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class NoteManager {
    private ArrayList<String> memory = new ArrayList<>();
    private static final String FILENAME = "notes.data";

    /**
     * 将内存中的笔记写入文件，以追加模式防止数据覆盖。
     */
    public void fileHandling() {
        // 使用 try-with-resources 确保 FileWriter 自动关闭
        try (FileWriter fWriter = new FileWriter(FILENAME, true)) { // 关键：设置为 true 启用追加模式
            // 每次写入时，只写入新添加的笔记，或者全部重写（根据实际需求调整）
            // 为了简化，这里假设每次都将 memory 中所有内容写入，
            // 但如果 memory 已经包含文件中的旧内容，则会重复。
            // 更好的做法是只写入新增的内容，或者在每次写入前清空文件再写入 memory 的所有内容。
            // 这里我们假设每次写入都是追加，所以需要确保 memory 中只包含需要追加的新内容。
            // 如果 memory 每次都清空，然后从文件读取，再添加新内容，那么每次写入就应该是覆盖模式。
            // 考虑到原始问题，我们希望每次添加新内容时，文件能保留旧内容并添加新内容。
            // 最直接的修改是：每次只写入新增的元素。
            // 但是，原始代码是每次将整个 ArrayList 写入文件。
            // 如果要保持原始逻辑，但又要追加，那么每次写入时，需要先清空文件，再写入所有内容。
            // 但这样又回到了覆盖问题。
            // 正确的理解是：如果每次都从文件读取到 memory，然后添加新内容，最后将 memory 写入文件，
            // 那么文件写入时应该是覆盖模式，因为 memory 已经包含了所有历史数据。
            // 如果 memory 只是临时的，每次只处理新输入，那么才需要追加模式。
            // 原始代码的意图是：memory 累积新输入，然后将 memory 写入文件。
            // 这里的核心是，如果 memory 是每次程序启动时重新构建的，那么每次写入都应该是覆盖。
            // 如果 memory 是持续存在的，那么每次写入新元素时，才需要考虑追加。
            // 针对原始问题“每次退出程序再运行，文件内容变空”，意味着 memory 在程序启动时是空的。
            // 所以，在程序启动时，需要将文件中的内容加载到 memory 中。
            // 然后，当有新内容加入 memory 后，再将 memory 的所有内容写入文件（覆盖模式），或者只将新内容追加到文件。
            // 鉴于原始代码每次写入 memory 的所有内容，最简单的修正是在程序启动时加载，然后写入时仍使用覆盖模式。
            // 但为了演示“追加模式”，我们假设 memory 只包含需要追加到文件的新数据。
            // 如果 memory 包含所有数据，那么写入文件时应使用覆盖模式，并在程序启动时加载。
            // 这里，我们先直接修正 FileWriter 为追加模式，解决“文件内容变空”的直接问题。
            // 稍后在“数据持久化”部分会说明完整的读写流程。

            // 原始代码逻辑是遍历 memory 写入所有内容。
            // 如果 memory 每次都从文件加载，然后添加新内容，再全部写入，那么这里应该用覆盖模式。
            // 但如果只是为了演示追加，我们假设 memory 只保存了需要追加的新内容。
            // 为了与原始问题更好地匹配，我们应该在程序启动时加载文件内容到 memory，
            // 然后每次写入时，将 memory 的所有内容写入文件（此时应使用覆盖模式）。
            // 考虑到原始问题描述和答案，答案是直接修改 FileWriter 为追加模式。
            // 这意味着，每次 fileHandling() 被调用时，它会将 memory 的当前内容追加到文件中。
            // 这会导致重复写入。

            // 更好的做法是：
            // 1. 程序启动时，从文件读取所有内容到 memory。
            // 2. 用户输入新内容，添加到 memory。
            // 3. 将 memory 的所有内容（包括旧的和新的）写入文件（使用覆盖模式）。
            // 这样能确保文件和 memory 始终同步。

            // 然而，为了直接回答原始问题，即“如何让文件不被清空”，我们先演示追加模式。
            // 这意味着每次调用 fileHandling()，memory 中的所有内容都会被追加到文件中。
            // 如果 memory 在程序运行期间不断增长，这会导致文件内容重复。
            // 真正的解决方案在下一节“实现数据持久化”中。
            // 这里我们只展示如何启用追加模式。
            for (String note : memory) { // 遍历 memory 中的所有元素
                fWriter.write(note + '\n');
            }
            // 每次写入后清空 memory，确保下次写入时不会重复？
            // 原始代码没有清空 memory，这意味着 memory 会累积。
            // 如果 memory 累积，且每次都追加到文件，那么文件内容会重复。
            // 因此，这里需要一个更完整的持久化策略。

        } catch (IOException e) {
            System.err.println("文件写入错误: " + e.getMessage());
        }
    }

    /**
     * 创建新笔记并保存。
     */
    public void createNote() {
        // ... (省略 Scanner 和日期时间格式化部分，与原始代码相同)
        // 假设这里获取了用户输入 note
        String note = "这是一个新笔记"; // 示例输入
        String dateTime = "2023-10-27 at 10:30:00 AM"; // 示例时间

        memory.add(note + " /" + dateTime); // 添加到内存
        fileHandling(); // 将内存内容写入文件 (此时会追加)
        System.out.println("Note is saved!\n");
    }

    // ... 其他方法
}

import java.io.*;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class PersistentNoteManager {
    private List<String> memory = new ArrayList<>();
    private static final String FILENAME = "notes.data";

    public PersistentNoteManager() {
        loadNotesFromFile(); // 程序启动时加载文件内容
    }

    /**
     * 从文件加载所有笔记到内存。
     */
    private void loadNotesFromFile() {
        File file = new File(FILENAME);
        if (!file.exists()) {
            System.out.println("笔记文件不存在，将创建新文件。");
            return; // 文件不存在，无需加载
        }

        try (BufferedReader reader = new BufferedReader(new FileReader(FILENAME))) {
            String line;
            while ((line = reader.readLine()) != null) {
                memory.add(line);
            }
            System.out.println("已从文件加载 " + memory.size() + " 条笔记。");
        } catch (IOException e) {
            System.err.println("加载笔记文件时发生错误: " + e.getMessage());
        }
    }

    /**
     * 将内存中的所有笔记写入文件。此方法使用覆盖模式，因为 memory 已经包含了所有历史数据。
     */
    public void saveNotesToFile() {
        // 使用 try-with-resources 确保 FileWriter 自动关闭
        // 此时应使用覆盖模式 (append = false 或不指定)，因为 memory 包含了所有数据
        try (BufferedWriter bWriter = new BufferedWriter(new FileWriter(FILENAME, false))) { // 覆盖模式
            for (String note : memory) {
                bWriter.write(note);
                bWriter.newLine(); // 写入换行符
            }
            System.out.println("所有笔记已保存到文件。");
        } catch (IOException e) {
            System.err.println("保存笔记文件时发生错误: " + e.getMessage());
        }
    }

    /**
     * 创建新笔记并添加到内存，然后保存到文件。
     */
    public void createNote() {
        Scanner insertNote = new Scanner(System.in);
        LocalDate todayDate = LocalDate.now();
        LocalTime nowTime = LocalTime.now();
        String timeFormat = nowTime.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM));
        String dateTime = todayDate.toString() + " at " + timeFormat;

        while (true) {
            System.out.println();
            System.out.println("Enter a note");
            System.out.print("> ");
            String note = insertNote.nextLine();

            if (note == null || note.trim().isEmpty()) { // 更好的空输入检查
                System.out.println("Invalid input! Try again");
                // break; // 如果是无效输入，不应该跳出循环，而是让用户重新输入
                continue; // 继续循环，让用户重新输入
            } else {
                memory.add(note + " /" + dateTime); // 添加到内存
                saveNotesToFile(); // 将内存内容写入文件 (此时是覆盖模式)
                System.out.println("Note is saved!\n");
                break; // 成功保存后跳出循环
            }
        }
        // insertNote.close(); // 注意：如果在循环内关闭，后续输入将无法使用。通常在程序结束时关闭。
    }

    public static void main(String[] args) {
        PersistentNoteManager manager = new PersistentNoteManager();
        // 示例：创建几条笔记
        manager.createNote();
        manager.createNote();

        // 可以在这里添加一个循环，让用户持续输入或查看笔记
        // 例如：
        // System.out.println("\n当前所有笔记:");
        // manager.memory.forEach(System.out::println);
    }
}