所以我有一个我自己类的对象的数组列表：
public class A
{...}
现在假设我有一个变量，它保存列表中的这些对象之一。现在我知道如果我更改该对象（例如在该对象上设置一个字段），这会更改保存对象本身的内存，因此两个引用（变量和在列表中保存对象的内部数组变量）仍然相同，并且仍然显示相同的，现在修改过的对象。正常行为！
但我也希望当我替换变量指向的列表中的对象时就是这种情况。那是我做的时候
myList.set(theObjectPosition, newInstanceOfA);
。在这种情况下，我还希望我的变量自动引用这个新实例。实现此类行为的最简单方法是什么？
这就是为什么我需要这个：
简而言之，我有一组类来处理对 ArrayList 所做的更改的撤消/冗余（我没有扩展，无论如何都不会解决问题？这些类称为
UndoAction, Add, Remove, Modify (the latter 3 inherit from UndoAction)
所有类都有方法undo（）和redo（）。
描述示例（如果需要，代码在末尾）：
假设我想将一个项目添加到列表中：我做了新的Add（myObject），然后我想修改列表中的项目，所以我做了新的修改（myObject），之后它会创建对象状态的DeepCopy作为备份，之后我自己更改对象（在完成对新Modify（..）的调用后）。然后我在 Modify 对象上撤消（），所以它确实 list.set（somePos，previousDeepCopy）（因此这篇文章，从本质上讲，制作的 deepcopy 是一个搞砸了事情的新实例!!）....
所以你可以想象这个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);
}
}
如果Java（ClassName）中的对象引用像C指针（ClassName*），你似乎想要像C指针到指针（ClassName**）的行为。
一种明显的方法是使 Holder 类的唯一目的是保存对类的引用。这样，您就可以更改对对象本身的引用，只要所有对象都保留对 Holder 的引用，它们现在也会指向新替换的对象。
public class AHolder{
public A aRef; // or private with getter setter.
}
我认为你需要额外的间接层。与其让其他代码引用"A"，您可能希望它引用"Stack"，并使用"peek（）"引用当前值（当您更改数组中的值时，您可能希望"push（）"新值）。
但是，为了代码的清洁，您可以通过将"A"变成一个接口并创建一个"A"的实现（我们称之为"DemissionatingStackAImpl"）来使其更整洁一些，该实现将提供与"A"相同的接口，除了支持"push（）"和"pop（）"并将调用转发到当前位于堆栈顶部的任何实例。因此，您不会破坏"A"的现有用法，同时仍然支持这个额外的间接层。
最简单的方法是确保你的类是"可变的"，也就是说，你可以用新对象之一改变内部状态。
myOldObject.replaceValues(myNewObject);
如果对象本身由于某种原因无法实现可变，只需围绕它构建一个包装器即可。
如果要替换的对象仅通过其接口引用，则可以首先使用 JDK 动态代理，该代理委托给实际实现。要更改实际实现，您需要修改代理调用处理程序。