存储图形对象是一个好主意吗？

不，存储对象通常是一个坏主意。:-)Graphics

原因如下：通常，实例的生存期很短，用于在某种表面上绘画或绘图（通常是 a 或 a ）。它保存这些绘图操作的状态，如颜色，笔触，缩放，旋转等。但是，它不保存绘图操作的结果或像素。Graphics(J)ComponentBufferedImage

因此，它不会帮助您实现撤消功能。像素属于组件或图像。因此，回滚到“上一个”对象不会将像素修改回上一个状态。Graphics

以下是我知道有效的一些方法：

• 使用命令的“链”（命令模式）来修改映像。命令模式在撤消/重做时工作得非常好（并在 Swing/AWT 中实现）。按顺序渲染所有命令，从原始命令开始。优点：每个命令中的状态通常不是那么大，允许您在内存中有许多步骤的撤消缓冲区。缺点：经过大量操作，它变得很慢...Action

• 对于每个操作，存储整个操作（如最初所做的那样）。优点：易于实施。缺点：你会很快耗尽内存。提示： 您可以序列化图像，使撤消/重做占用更少的内存，但代价是处理时间更长。BufferedImage

• 上述方法的组合，使用命令模式/链的想法，但在合理的情况下使用“快照”（as）优化渲染。这意味着您不需要从一开始就为每个新操作渲染所有内容（更快）。还要将这些快照刷新/序列化到磁盘，以避免内存不足（但为了速度，如果可以的话，请将它们保留在内存中）。您还可以将命令序列化到磁盘，以便几乎无限制地撤消。优点：如果做得好，效果很好。缺点：需要一些时间才能正确。BufferedImages

PS：对于上述所有内容，您需要使用后台线程（喜欢或类似）来更新显示的图像，将命令/图像存储到后台的磁盘等，以保持响应式UI。SwingWorker

祝你好运！:-)

想法#1，存储对象根本行不通。不应将其视为“持有”某些显示内存，而应将其视为访问显示内存区域的句柄。在 的情况下，每个对象将始终是同一给定图像内存缓冲区的句柄，因此它们都将表示相同的图像。更重要的是，您实际上无法对存储的图形执行任何操作：由于它们不存储任何内容，因此它们无法“重新存储”任何内容。GraphicsGraphicsBufferedImageGraphics

想法#2，克隆s是一个更好的主意，但你确实会浪费内存，并很快耗尽它。它有助于存储受绘制影响的图像部分，例如使用矩形区域，但它仍然会消耗大量内存。将这些撤消图像缓冲到磁盘可能会有所帮助，但它会使您的UI缓慢且无响应，这很糟糕;此外，它使您的应用程序更加复杂且容易出错。BufferedImage

我的替代方案是将图像修改存储在一个列表中，从图像顶部的第一个到最后一个呈现。然后，撤消操作仅包括从列表中删除修改。

这要求您“重新化”图像修改，即通过提供执行实际绘图的方法创建一个实现单个修改的类。void draw(Graphics gfx)

正如你所说，随机修改会带来一个额外的问题。但是，关键问题是您使用 来创建随机数。相反，使用从固定种子值创建的 执行每个随机修改，以便每次调用 时（伪）随机数序列相同，即每次绘制具有完全相同的效果。（这就是为什么它们被称为“伪随机”——生成的数字看起来是随机的，但它们和任何其他函数一样具有确定性。Math.random()Randomdraw()

与具有内存问题的图像存储技术相比，这种技术的问题在于许多修改可能会使GUI变慢，特别是如果修改是计算密集型的。为了防止这种情况，最简单的方法是修复可撤消修改列表的适当最大大小。如果通过添加新修改会超过此限制，请删除列表中最旧的修改并将其应用于后备本身。BufferedImage

以下简单的演示应用程序表明（以及如何）所有这些功能协同工作。它还包括一个很好的“重做”功能，用于重做未完成的操作。

package stackoverflow;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.util.LinkedList;
import java.util.Random;
import javax.swing.*;

public final class UndoableDrawDemo
        implements Runnable
{
    public static void main(String[] args) {
        EventQueue.invokeLater(new UndoableDrawDemo()); // execute on EDT
    }

    // holds the list of drawn modifications, rendered back to front
    private final LinkedList<ImageModification> undoable = new LinkedList<>();
    // holds the list of undone modifications for redo, last undone at end
    private final LinkedList<ImageModification> undone = new LinkedList<>();

    // maximum # of undoable modifications
    private static final int MAX_UNDO_COUNT = 4;

    private BufferedImage image;

    public UndoableDrawDemo() {
        image = new BufferedImage(600, 600, BufferedImage.TYPE_INT_RGB);
    }

    public void run() {
        // create display area
        final JPanel drawPanel = new JPanel() {
            @Override
            public void paintComponent(Graphics gfx) {
                super.paintComponent(gfx);

                // display backing image
                gfx.drawImage(image, 0, 0, null);

                // and render all undoable modification
                for (ImageModification action: undoable) {
                    action.draw(gfx, image.getWidth(), image.getHeight());
                }
            }

            @Override
            public Dimension getPreferredSize() {
                return new Dimension(image.getWidth(), image.getHeight());
            }
        };

        // create buttons for drawing new stuff, undoing and redoing it
        JButton drawButton = new JButton("Draw");
        JButton undoButton = new JButton("Undo");
        JButton redoButton = new JButton("Redo");

        drawButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // maximum number of undo's reached?
                if (undoable.size() == MAX_UNDO_COUNT) {
                    // remove oldest undoable action and apply it to backing image
                    ImageModification first = undoable.removeFirst();

                    Graphics imageGfx = image.getGraphics();
                    first.draw(imageGfx, image.getWidth(), image.getHeight());
                    imageGfx.dispose();
                }

                // add new modification
                undoable.addLast(new ExampleRandomModification());

                // we shouldn't "redo" the undone actions
                undone.clear();

                drawPanel.repaint();
            }
        });

        undoButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if (!undoable.isEmpty()) {
                    // remove last drawn modification, and append it to undone list
                    ImageModification lastDrawn = undoable.removeLast();
                    undone.addLast(lastDrawn);

                    drawPanel.repaint();
                }
            }
        });

        redoButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if (!undone.isEmpty()) {
                    // remove last undone modification, and append it to drawn list again
                    ImageModification lastUndone = undone.removeLast();
                    undoable.addLast(lastUndone);

                    drawPanel.repaint();
                }
            }
        });

        JPanel buttonPanel = new JPanel(new FlowLayout());
        buttonPanel.add(drawButton);
        buttonPanel.add(undoButton);
        buttonPanel.add(redoButton);

        // create frame, add all content, and open it
        JFrame frame = new JFrame("Undoable Draw Demo");
        frame.getContentPane().add(drawPanel);
        frame.getContentPane().add(buttonPanel, BorderLayout.NORTH);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    //--- draw actions ---

    // provides the seeds for the random modifications -- not for drawing itself
    private static final Random SEEDS = new Random();

    // interface for draw modifications
    private interface ImageModification
    {
        void draw(Graphics gfx, int width, int height);
    }

    // example random modification, draws bunch of random lines in random color
    private static class ExampleRandomModification implements ImageModification
    {
        private final long seed;

        public ExampleRandomModification() {
            // create some random seed for this modification
            this.seed = SEEDS.nextLong();
        }

        @Override
        public void draw(Graphics gfx, int width, int height) {
            // create a new pseudo-random number generator with our seed...
            Random random = new Random(seed);

            // so that the random numbers generated are the same each time.
            gfx.setColor(new Color(
                    random.nextInt(256), random.nextInt(256), random.nextInt(256)));

            for (int i = 0; i < 16; i++) {
                gfx.drawLine(
                        random.nextInt(width), random.nextInt(height),
                        random.nextInt(width), random.nextInt(height));
            }
        }
    }
}