Java对象添加/更新/删除算法

我正在寻找一种算法，它将以最高效的方式定期更新我拥有的Java对象列表。算法需要

当前集

A, B, C

调用Reload指令并从数据库返回一个新集合

A, C, D

（如有必要，

A

和

C

应更新，

B

需要删除&

D

是新的，应创建）

---

显然，我可以杀死所有对象，每次只重新创建所有对象，但我希望避免杀死任何未更改的对象（即，如果数据库中的

A

&

C

没有更改，那么当前的Java

A

&

C

对象应该以当前的形式继续）

---

我需要一个好的算法来完成这些不同的检查，然后根据需要添加/更新/删除。我的情况的逻辑应该能够从一个简单的

ArrayList

示例继承下来，我认为很明显我的

a

/

B

/

C

对象要复杂得多。

您可以有两个列表，一个用于BusinessLayer，另一个用于UI层，并相应地将对象标记为create/update/delete。

---

一旦识别出该标记列表，就可以相应地转发以创建DB查询。

您可以有两个列表，一个用于BusinessLayer，另一个用于UI layer，并相应地将对象标记为create/update/delete。

---

一旦识别出该标记列表，就可以相应地转发以创建DB查询。

您需要一个

HashMap

，其中数据库ID为键，完整对象为值。您将迭代结果集，并通过一个O（1）操作，找出该项是否已经存在。然后，您可以根据需要添加和更新。继续操作时，为所有获取的条目的数据库键构建一个临时的

HashSet

。然后执行最后的设置差异，以查找要从运行时副本中删除的项。

您需要一个

HashMap

，其中数据库ID为键，完整对象为值。您将迭代结果集，并通过一个O（1）操作，找出该项是否已经存在。然后，您可以根据需要添加和更新。继续操作时，为所有获取的条目的数据库键构建一个临时的

HashSet

。然后进行最后的设置差异，以查找要从运行时副本中删除的项目。

我建议您应该为设置使用映射。这将使查找更加有效

你可以做几个循环来找出发生了什么变化

Map<MyKey, MyType> previous = ..
Map<MyKey, MyType> current = ..

for(Map<MyKey, MyType> entry: current.entrySet()) {
  MyType t = entry.getValue();
  MyType p = previous.get(entry.getKey());
  if (p == null)
      added(t);
  else if (!p.equals(t))
      updated(p, t);
}
for(Map<MyKey, MyType> entry: previous.entrySet()) {
  if(!current.contains(entry.getKey()))
     removed(entry.getValue());
}

Map-previous=。。
映射当前=。。
for（映射条目：current.entrySet（））{
MyType t=entry.getValue（）；
MyType p=previous.get（entry.getKey（））；
if（p==null）
添加（t）；
else如果（！p.等于（t））
更新（p，t）；
}
for（映射条目：previous.entrySet（））{
如果（！current.contains（entry.getKey（）））
已删除（entry.getValue（））；
}

我建议你应该为你的布景使用地图。这将使查找更加有效

你可以做几个循环来找出发生了什么变化

Map<MyKey, MyType> previous = ..
Map<MyKey, MyType> current = ..

for(Map<MyKey, MyType> entry: current.entrySet()) {
  MyType t = entry.getValue();
  MyType p = previous.get(entry.getKey());
  if (p == null)
      added(t);
  else if (!p.equals(t))
      updated(p, t);
}
for(Map<MyKey, MyType> entry: previous.entrySet()) {
  if(!current.contains(entry.getKey()))
     removed(entry.getValue());
}

Map-previous=。。
映射当前=。。
for（映射条目：current.entrySet（））{
MyType t=entry.getValue（）；
MyType p=previous.get（entry.getKey（））；
if（p==null）
添加（t）；
else如果（！p.等于（t））
更新（p，t）；
}
for（映射条目：previous.entrySet（））{
如果（！current.contains（entry.getKey（）））
已删除（entry.getValue（））；
}

解决方案1 对象可以从基类型继承，例如：

abstract class PersistentObject {
    private boolean persistent;  // true if exists in database
    private boolean modified;    // true if modified
    private boolean deleted;     // true if deleted

    public boolean isPersistent() { return persistent; }
    protected void setPersistent() { persistent = true; }

    public boolean isModified() { return modified; }
    protected void setModified() { modified = true; }

    public boolean isDeleted() { return deleted; }
    protected void setDeleted() { deleted = true; }
}

并在操作对象时调用/更改对象的状态。例如：

public void setSomeIntvalue(int value) {
    this.value = value;

    setModified();
}

class SomeObject extends BaseEntity<SomeObject> { 
    public void setSomeThing(...) {
        ...
        setModified();
    }
}

提交更改（在集合上迭代）时，从数据库中删除任何已删除的对象，然后将其从集合中删除。如果

isPersistent（）

为false，则创建一个新的，如果

isModified（）

为true，则

更新它，否则什么也不做

解决方案2
您可以使用包装器来管理对象集。比如：

abstract class AbstractEntitySet<E> {
    private HashSet<E> createdSet = new HashSet<E>();
    private HashSet<E> modifiedSet = new HashSet<E>();
    private HashSet<E> deletedSet = new HashSet<E>();

    public void add(E e) {
        add(e, false);
    }

    public void add(E e, boolean modified) {
        if (modified) {
            createdSet.remove(e);
            modifiedSet.add(e);
            deletedSet.remove(e);
        } else {
            createdSet.add(e);
            modifiedSet.remove(e);
            deletedSet.remove(e);
        }
    }

    public void remove(E e) {
        createdSet.remove(e);
        modifiedSet.remove(e);
        deletedSet.add(e);
    }

    public void applyChanges() {
        for (E e : createdSet) {
            createEntity(e);
        }
        createdSet.clear();

        for (E e : modifiedSet) {
            updateEntity(e);
        }
        modifiedSet.clear();

        for (E e : deletedSet) {
            deleteEntity(e);
        }
        deletedSet.clear();
    }

    protected abstract void createEntity(E e);
    protected abstract void updateEntity(E e);
    protected abstract void deleteEntity(E e);
}

解决方案3
您还可以在应用程序中使用现有的持久性层，如或。
Solution 1
对象可以从基类型继承，例如：

abstract class PersistentObject {
    private boolean persistent;  // true if exists in database
    private boolean modified;    // true if modified
    private boolean deleted;     // true if deleted

    public boolean isPersistent() { return persistent; }
    protected void setPersistent() { persistent = true; }

    public boolean isModified() { return modified; }
    protected void setModified() { modified = true; }

    public boolean isDeleted() { return deleted; }
    protected void setDeleted() { deleted = true; }
}

并在操作对象时调用/更改对象的状态。例如：

public void setSomeIntvalue(int value) {
    this.value = value;

    setModified();
}

class SomeObject extends BaseEntity<SomeObject> { 
    public void setSomeThing(...) {
        ...
        setModified();
    }
}

提交更改（在集合上迭代）时，从数据库中删除任何已删除的对象，然后将其从集合中删除。如果
isPersistent（）
为false，则创建一个新的，如果
isModified（）
为true，则
更新它，否则什么也不做

解决方案2
您可以使用包装器来管理对象集。比如：

abstract class AbstractEntitySet<E> {
    private HashSet<E> createdSet = new HashSet<E>();
    private HashSet<E> modifiedSet = new HashSet<E>();
    private HashSet<E> deletedSet = new HashSet<E>();

    public void add(E e) {
        add(e, false);
    }

    public void add(E e, boolean modified) {
        if (modified) {
            createdSet.remove(e);
            modifiedSet.add(e);
            deletedSet.remove(e);
        } else {
            createdSet.add(e);
            modifiedSet.remove(e);
            deletedSet.remove(e);
        }
    }

    public void remove(E e) {
        createdSet.remove(e);
        modifiedSet.remove(e);
        deletedSet.add(e);
    }

    public void applyChanges() {
        for (E e : createdSet) {
            createEntity(e);
        }
        createdSet.clear();

        for (E e : modifiedSet) {
            updateEntity(e);
        }
        modifiedSet.clear();

        for (E e : deletedSet) {
            deleteEntity(e);
        }
        deletedSet.clear();
    }

    protected abstract void createEntity(E e);
    protected abstract void updateEntity(E e);
    protected abstract void deleteEntity(E e);
}

解决方案3
您还可以在应用程序中使用现有的持久性层，例如，或。
您是否在数据库和Java代码之间使用缓存/持久性层？“显然，我可以杀死所有对象，并在每次“抱歉”fge时重新创建所有对象”但我不能转储该对象，因为该对象的生存时间越长，就会生成某些正在进行的统计计算。删除和重新创建将意味着不必要地丢失这些值。您是否在数据库和Java代码之间使用了缓存/持久层？“显然，我可以杀死所有对象，每次“抱歉”fge都重新创建它们”但我不能转储该对象，因为该对象的生存时间越长，就会生成某些正在进行的统计计算。删除和重新创建将意味着不必要地丢失这些值。谢谢Marko。现在，我正在遍历新的DB结果集，一路上添加/更新每个结果集。执行此操作时，将每个添加/更新记录记录记录到hashmap中。在结果集循环完成后，然后循环所有活动对象，并依次与临时hashmap进行比较。那些在地图中的，在添加/更新时忽略，那些不在地图中的需要删除。谢谢Marko。现在，我正在遍历新的DB结果集ad