Java如何实现撤销功能？

在Java中实现撤销(Undo)功能是许多应用程序（如文本编辑器、图形工具、表单处理等）的核心需求，它不仅能提升用户体验，还能增强应用的交互性，下面将详细解释两种主流实现方案（命令模式、备忘录模式），并提供代码示例、优化技巧及适用场景。

撤销功能的实现原理

撤销的核心是记录操作状态变化，并在需要时回退到之前的状态，常用的设计模式有两种：

1. 命令模式 (Command Pattern)
   将用户操作封装成独立对象，存储操作前后的状态变化。
2. 备忘录模式 (Memento Pattern)
   保存对象的完整快照，撤销时直接恢复快照。

实现方案一：命令模式（推荐）

通过封装操作为对象,实现操作记录与撤销逻辑。

核心步骤：

1. 定义Command接口（包含执行与撤销方法）。
2. 创建具体命令类（实现具体操作）。
3. 维护一个操作历史栈（Deque）。

代码示例：

interface Command {
    void execute(); // 执行操作
    void undo();    // 撤销操作
}
// 示例：文本添加命令
class AppendTextCommand implements Command {
    private StringBuilder text;
    private String addedText;
    private int startIndex;
    public AppendTextCommand(StringBuilder text, String addedText) {
        this.text = text;
        this.addedText = addedText;
    }
    @Override
    public void execute() {
        startIndex = text.length(); // 记录原始位置
        text.append(addedText);     // 执行添加
    }
    @Override
    public void undo() {
        text.delete(startIndex, text.length()); // 删除添加的内容
    }
}
// 操作历史管理器
class CommandManager {
    private Deque<Command> history = new ArrayDeque<>(); // 操作历史栈
    public void executeCommand(Command cmd) {
        cmd.execute();
        history.push(cmd); // 记录操作
    }
    public void undo() {
        if (!history.isEmpty()) {
            Command cmd = history.pop();
            cmd.undo(); // 撤销
        }
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        StringBuilder text = new StringBuilder("Hello");
        CommandManager manager = new CommandManager();
        // 添加文本并执行
        Command appendCmd = new AppendTextCommand(text, " World!");
        manager.executeCommand(appendCmd); // 文本变成 "Hello World!"
        // 撤销操作
        manager.undo(); // 文本恢复为 "Hello"
    }
}

优点：

• 精细控制操作细节,内存占用低。
• 支持重做（新增redoStack存储已撤销操作）。

实现方案二：备忘录模式

保存对象的完整状态快照（Memento），撤销时恢复快照。

核心步骤：

1. 定义原始对象（生成/恢复快照）。
2. 定义备忘录类（存储对象状态）。
3. 管理者类（保存历史快照栈）。

代码示例：

// 原始对象（需支持撤销的类）
class Document {
    private String content;
    public void setContent(String content) {
        this.content = content;
    }
    public String getContent() {
        return content;
    }
    // 创建快照
    public Memento save() {
        return new Memento(content);
    }
    // 恢复快照
    public void restore(Memento memento) {
        this.content = memento.getSavedContent();
    }
    // 备忘录类（内部类保证封装性）
    public static class Memento {
        private final String content;
        private Memento(String content) {
            this.content = content;
        }
        private String getSavedContent() {
            return content;
        }
    }
}
// 快照管理器
class History {
    private Deque<Document.Memento> stack = new ArrayDeque<>();
    public void push(Document.Memento memento) {
        stack.push(memento);
    }
    public Document.Memento pop() {
        return stack.pop();
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        Document doc = new Document();
        History history = new History();
        doc.setContent("Version 1");
        history.push(doc.save()); // 保存状态
        doc.setContent("Version 2"); // 修改内容
        doc.restore(history.pop()); // 撤销到Version 1
    }
}

优点：

• 状态恢复简单直接。
• 适合对象结构简单的场景（如配置管理）。

缺点：

• 频繁快照可能占用大量内存（需优化存储）。

两种方案的对比与选择

优化技巧

1. 内存优化

   • 命令模式：存储操作差异而非完整状态。
   • 备忘录模式：使用序列化存储快照到磁盘（ObjectOutputStream）。

2. 重做功能
   扩展CommandManager，增加redoStack：

   class CommandManager {
       private Deque<Command> undoStack = new ArrayDeque<>();
       private Deque<Command> redoStack = new ArrayDeque<>();
       public void executeCommand(Command cmd) {
           cmd.execute();
           undoStack.push(cmd);
           redoStack.clear(); // 新操作清除重做栈
       }
       public void undo() {
           if (!undoStack.isEmpty()) {
               Command cmd = undoStack.pop();
               cmd.undo();
               redoStack.push(cmd);
           }
       }
       public void redo() {
           if (!redoStack.isEmpty()) {
               Command cmd = redoStack.pop();
               cmd.execute();
               undoStack.push(cmd);
           }
       }
   }

3. 撤销次数限制
   设置栈的最大容量（如new ArrayDeque<>(50)），避免内存溢出。

   

常见问题

1. 如何避免内存泄漏？
   使用弱引用（WeakReference）存储状态，或限制历史记录数量。
2. 多线程环境下如何安全撤销？
   使用同步锁（如synchronized）保护历史栈操作。
3. 支持跨会话撤销？
   将操作历史序列化到文件/数据库（如java.io.Serializable）。

Java实现撤销功能的核心在于状态管理：

• 命令模式：优先选择，适合高频操作，灵活且内存可控。
• 备忘录模式：适合简单对象，需警惕内存问题。
  实际开发中可结合业务需求，通过限制历史记录数量或增量存储优化性能，完整代码示例可在GitHub示例库中查看。

参考文献

1. Gamma, E. et al. Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1994).
2. Oracle Java Docs: Deque Interface.
3. Baeldung: The Command Pattern in Java.