Question

所以我有一个我自己类的对象的ArrayList：

public class A
{...}

现在说我有一个变量，它从列表中包含其中一个对象。现在我知道如果我改变那个对象（例如在该对象上设置一个字段），这会改变保存对象的内存，因此两个引用（变量和保存列表中对象的内部数组变量）仍然是相同，两者仍然显示相同，现在修改，对象。正常行为！

但是当我替换我的变量所指向的列表中的对象时，我也希望如此。那是我做的时候

myList.set(theObjectPosition, newInstanceOfA);

...在这种情况下，我还希望我的变量能够自动引用这个新实例。实现此类行为的最简单方法是什么？

这就是我需要这个的原因：

简而言之，我有一组类来处理对ArrayList所做的更改的undos / redos（我还没有扩展，无论如何都无法解决问题？）。这些类叫做

UndoAction, Add, Remove, Modify (the latter 3 inherit from UndoAction)

所有类都有方法undo（）和redo（）。

通过描述示例（如果需要，代码在最后）：

说我想要一个项目添加到List：我做新的Add（myObject），然后我想修改列表中的项目，所以我做了新的Modify（myObject），之后它创建了一个对象的DeepCopy状态为备份，之后我自己更改对象（在完成对新修改（...）的调用之后）。然后我在Modify对象上执行undo（），所以它确实是list.set（somePos，previousDeepCopy）（因此这篇帖子，本质上是深度复制的，是一个新的实例，它会让事情变得糟透了！）.... / p>

所以你可以想象这个list.set会带来一些问题。对替换对象的任何引用都将消失。所以我无法有效地使用列表，如果它总是替换对这类对象的引用，因此我的撤销管理器注定会失败。

那我该如何对抗这些设计缺陷呢？欢迎任何建议。

一些代码：

 protected abstract class UndoAction {
    protected HashSet<Integer> ids = new HashSet<Integer>();
    protected Marker marker;

    public UndoAction(List<E> l) {
      for (E e : l) {
        if (!entities.contains(e)) {
          entities.add(e);
          trace.append(entities.indexOf(e), new Stack<UndoAction>());
        }
        ids.add(entities.indexOf(e));
      }
    }

    public boolean sameAffectedTargets(UndoAction undoAction) {
      if (this.ids.containsAll(undoAction.ids) && undoAction.ids.containsAll(this.ids))
        return true;
      return false;
    }

    public Marker getMarker() {
      return new Marker(this);
    }

    public void firstRun() {
    }

    public void undo() {
    }

    public void redo() {
    }

    protected List<Data> getCopyEntities() {
      List<Data> l = new ArrayList<Data>();
      for (Integer id : ids) {
        E e = entities.get(id);
        int pos = adapterList.indexOf(e);
        l.add(new Data(id, pos, e));
      }
      return l;
    }

    protected List<Data> getDeepCopyEntities() {
      List<Data> l = new ArrayList<Data>();
      for (Integer id : ids) {
        E e = DeepCopy.copy(entities.get(id));
        int pos = adapterList.indexOf(entities.get(id));
        l.add(new Data(id, pos, e));
      }
      return l;
    }

    public void addEntities(List<Data> datas) {
      for (Data d : datas)
        d.addEntity();
    }

    public void setEntities(List<Data> datas) {
      for (Data d : datas)
        d.setEntity();
    }

    public void removeEntities(List<Data> datas) {
      for (Data d : datas)
        d.removeEntity();
    }

    protected class Data {
      public int id;
      public int pos;
      public E entity;

      public void addEntity() {
        entities.set(this.id, this.entity);
        adapterList.add(this.pos, this.entity);
      }

      public void setEntity() {
        entities.set(this.id, this.entity);
        E oldEntity = adapterList.get(this.pos);
        adapterList.set(this.pos, this.entity);
        notifyEntityReplaced(oldEntity, adapterList.get(this.pos), this.pos);
      }

      public void removeEntity() {
        entities.set(this.id, null);
        adapterList.remove(this.entity);
      }

      public Data(int id, int pos, E entity) {
        this.id = id;
        this.pos = pos;
        this.entity = entity;
      }
    }
  }

  protected class Add extends UndoAction {
    protected List<Data> addBackup;

    public Add(List<E> l) {
      super(l);
    }

    @Override
    public void undo() {
      super.undo();
      addBackup = getCopyEntities();
      removeEntities(addBackup);
    }

    @Override
    public void firstRun() {
      super.firstRun();
      adapterList.addAll(entities);
    }

    @Override
    public void redo() {
      super.redo();
      addEntities(addBackup);
    }
  }

  // call before modifying
  protected class Modify extends UndoAction {
    protected List<Data> beforeDeepCopies;
    protected List<Data> afterDeepCopies;

    public Modify(List<E> l) {
      super(l);
    }

    @Override
    public void undo() {
      super.undo();
      if (!skipModifying) {
        if (afterDeepCopies == null)
          afterDeepCopies = getDeepCopyEntities();
        setEntities(beforeDeepCopies);
      }
    }

    @Override
    public void firstRun() {
      super.firstRun();
      if (!skipModifying) // TODO
        beforeDeepCopies = getDeepCopyEntities();
    }

    @Override
    public void redo() {
      super.redo();
      if (!skipModifying)
        setEntities(afterDeepCopies);
    }
  }

  protected class Remove extends UndoAction {
    protected List<Data> removeBackup;

    public Remove(List<E> l) {
      super(l);
    }

    public List<E> getRemoved() {
      List<E> l = new ArrayList<E>();
      for (Data data : removeBackup)
        l.add(data.entity);
      return l;
    }

    @Override
    public void undo() {
      super.undo();
      addEntities(removeBackup);
    }

    @Override
    public void firstRun() {
      super.firstRun();
      removeBackup = getCopyEntities();
    }

    @Override
    public void redo() {
      super.redo();
      removeEntities(removeBackup);
    }
  }

Answer 1

如果Java中的对象引用（ClassName）类似于C指针（ClassName*），那么您似乎需要像指针（ClassName**）的C指针这样的行为。

一个显而易见的方法是制作Holder课程，其唯一目的是为您的课程提供参考。这样你就可以改变对象本身的引用，只要所有引用都持有对Holder的引用，它们现在也会指向新替换的对象。

public class AHolder{
    public A aRef; // or private with getter setter.
}

Answer 2

最简单的方法就是确保您的类是“可变的”，也就是说，您可以使用新对象之一更改内部状态。

myOldObject.replaceValues(myNewObject);

如果对象本身由于某种原因无法做到可变，那么只需在它周围构建一个包装器。

Answer 3

我认为你需要一个额外的间接层。您可能希望它引用“Stack＆lt; A＆gt;”而不是让其他代码引用“A”，并使用“peek（）”来引用当前值（当您更改数组中的值时，您将可能想“推（）”新值。）

然而，为了代码清洁，你可以通过将“A”放入一个接口并创建一个“A”的实现（让我们称之为“DelegatingStackAImpl”）来提供相同的接口。 “A”除了支持“push（）”和“pop（）”并将调用转发到当前位于堆栈顶部的任何实例。因此，您仍然不会破坏“A”的现有用途，同时仍然支持这个额外的间接层。

Answer 4

如果要替换的对象仅通过其接口引用，那么您可以首先使用JDK dynamic proxy，它将委派给实际的实现。要更改实际实现，您需要修改代理调用处理程序。

替换（不更改）对象时Java自动更新所有引用？

4 个答案: