在ArrayList中使用命令模式实现撤销和重做

Question

所以我有一个程序，你可以登录并将朋友添加到和从friends数组列表中删除。此外，我可以喜欢某个东西，并将该物品存储到likes数组列表中。我被要求为我所做的任何操作制作撤消和重做选项。

所以我想把apple添加为一个朋友。之后当我选择撤消选项时，我可以撤消那个动作，这样apple就不会是我的朋友了。如果输入是我输入的任何名称或单词来存储到friends数组列表中，我该如何使用Command Pattern来处理？

我进行了一些研究，发现使用命令模式可能是最好的选择，因为这必须在我已经拥有的Facebook Class下完成。我假设我将不得不使用两个不同的堆栈，但我在这个主题上有点迷失了。

我决定添加一些我所拥有的部分，以便我可以更好地了解我需要做什么以及我的程序的功能。

在驱动程序中

Facebook facebook1 = new Facebook();

            if (userInput == 6) 
            {
                System.out.println("Login");
                String operand1 = getOperand("What is the Username? ");
                String operand2 = getOperand("What is the Password? ");
                System.out.println("Enter a friend to be added. ");
                String operand3 = getOperand("What is the Username? ");
                facebook1.friend(operand3);
            }

            if (userInput == 7) 
            {
                System.out.println("Login");
                String operand1 = getOperand("What is the Username? ");
                String operand2 = getOperand("What is the Password? ");
                System.out.println("Enter a friend to be removed. ");
                String operand3 = getOperand("What is the Username? ");
                facebook1.defriend(operand3);
            }
            if (userInput == 12) 
            {
                System.out.println("Login");
                String operand1 = getOperand("What is the Password? ");
                facebook1.undo();
            }

            if (userInput == 13) 
            {
                System.out.println("Login");
                String operand1 = getOperand("What is the Password? ");
                facebook1.redo();
            }

在Facebook班级中

ArrayList<FacebookUser> recommendedFriends = new ArrayList<FacebookUser>();

void friend(String newFriend)
    {
        boolean positiveChecker = false;

        for (int i = 0; i < recommendedFriends.size(); i++) 
        {

            if (recommendedFriends.get(i).toString().equalsIgnoreCase(newFriend)) 
            {
                System.out.println("Error: This friend already exists.");
                positiveChecker = true;
            }

        }
        if (positiveChecker == false) 
        {
            FacebookUser friend = new FacebookUser(newFriend, newFriend );
            recommendedFriends.add(friend);
            System.out.println(friend + " is now your friend.");
        }
        positiveChecker = false;
    }

     void defriend(String formerFriend)
    {
         boolean positiveChecker = false;

            for (int i = 0; i < recommendedFriends.size(); i++) 
            {

                if (recommendedFriends.get(i).toString().equalsIgnoreCase(formerFriend)) 
                {
                    recommendedFriends.remove(i);
                    System.out.println(formerFriend + " has been removed from your friends list.");
                    positiveChecker = true;
                }
                if (recommendedFriends.size() == (i + 1) && recommendedFriends.get(i).toString() != formerFriend
                        && positiveChecker == false) 
                {
                    System.out.println("Error: There is no friend with this username.");

                }

            }
            positiveChecker = false;
    }

public interface Command 
    {
        public void undo();
        public void redo();
    }

- Ultimania

---

可能是Java中撤销和重做实现的重复问题。链接 - Bruno Ribeiro

如果我没记错的话，您只需要一个栈。 - Ray Tayek

Answer 1

当您撤销两个操作后执行一个全新的操作时，您需要“忘记”“重做历史记录”，并用新命令替换它，对吗？

例如...

1. 添加好友Jim 2. 添加好友Bill 3. 添加好友Jill 4. 删除Jim 5. 撤销 6. 撤销

状态应为“Jim”和“Bill”。

因此，您只需要一个列表和指向当前“命令”的指针，例如...

// Note: NOT thread safe!
public class CommandStack {
    private List<Command> commands = Collections.emptyList();
    private int nextPointer = 0;

    public void doCommand(Command command) {
        List<Command> newList = new ArrayList<>(nextPointer + 1)

        for(int k = 0; k < nextPointer; k++) {
            newList.add(commands.get(k));
        }

        newList.add(command);

        commands = newList;
        nextPointer++;

        // Do the command here, or return it to whatever called this to be done, or maybe it has already been done by now or something
        // (I can only guess on what your code currently looks like...)
        command.execute();
    }

    public boolean canUndo() {
        return nextPointer > 0;
    }

    public void undo() {
        if(canUndo()) {
            nextPointer--;
            Command commandToUndo = commands.get(nextPointer);
            // Undo the command, or return it to whatever called this to be undone, or something
            command.undo();
         } else {
             throw new IllegalStateExcpetion("Cannot undo");
         }
    }

    public boolean canRedo() {
        return nextPointer < commands.size();
    }

    public void redo() {
        if(canRedo()) {
            commandToDo = commands.get(nextPointer);
            nextPointer++;
            // Do the command, or return it to whatever called this to be re-done, or something
            commandToDo.execute();
        } else {
            throw new IllegalStateException("Cannot redo");
        }
    }
}

如果我有...

interface Command { /* execute / undo etc */ }

public class AddFriendCommand implements Command {
    private String friendName;

    // ... other fields, constructor / getters etc ...

    public void execute() {
        // Actually do it...
        System.out.println("Added friend " + name);
    }

    public void undo() {
        // Undo it...
        System.out.println("Removed friend " + name);
    }
}

public class RemoveFriendCommand implements Command {
    private String friendName;

    // ... other fields, constructor / getters etc ...

    public void execute() {
        // Actually do it, maybe throw exception if friend does not exist?
        // (that would have to be a runtime exception unless you want the interface's method to throw stuff);
        System.out.println("Removed friend " + name);
    }

    public void undo() {
        // Undo it...
        System.out.println("Added friend " + name);
    }
}

您可以使用相同的顺序重复上述步骤，使用...

CommandStack stack = new CommandStack();

stack.doCommand(new AddFriendCommand("Jim"));
stack.doCommand(new AddFriendCommand("Bill"));
stack.doCommand(new AddFriendCommand("Jill"));
stack.doCommand(new RemoveFreindCommand("Jim"));

stack.undo();
stack.undo();

如果您现在执行一个新的命令（通过doCommand），它将忘记您曾经添加过“Jill”或删除过“Jim”，而是现在会记住新的命令和未被撤消的其余命令历史记录。希望这可以帮助您。

- BretC

---

我添加了更多的代码，以使您更容易理解。这是否意味着我需要创建一个新类并使用指针来实现命令接口？ - Ultimania

Answer 2

你误解了命令模式的工作原理。你需要有一个单独的List来存储你的Commands，其中每个Command实例代表一个动作。

因此，你需要像这样做：

List<Command> actionStack;

然后有这样的东西

public class AddCommand implements Command {
    private final void List<FacebookUser> userList;
    private final void FacebookUser newUser;

    public AddCommand(List<FacebookUser> userList, FacebookUser newUser) {
        this.userList = userList;
        this.newUser = newUser;
    }

    @Override
    public void undo() {
        userList.remove(newUser);
    }

    @Override
    public void redo() {
        userList.add(newUser);
    }
}

- durron597

---

我仍然需要一点帮助。我可以把我的代码给你，这样会方便一些吗？ - Ultimania

@user2904667 可以放心地编辑您的问题，描述您具体的问题。不要仅仅把所有的代码都粘贴上来。 - durron597

希望这能让你更好地帮助我。 - Ultimania