Question

我有一个简单的对象类，它有两个字段：id＆amp; name

public class MyObject{
   private int id; //unique id for each instance of MyObject
   private String name;

   //Setter & Getter
   ...
}

现在我有两个List个实例，每个实例都有List个MyObject：

 /*it holds a list of MyObject*/
 List<MyObject> list_origin = GET_MyObject1();

 /*it holds a subset of above list, moreover, the subset objects with the 
   same 'id' as objects in above list have different 'name' value*/
 List<MyObject> list_update = GET_MyObject2();

list_update实际上拥有list_origin的子集，但已更新（不同）name值。

现在，我需要使用list_origin更新list_update（即将list_origin中的对象替换为list_update中的对象），最有效的方式是什么？做到了吗？

Answer 1

如果使用list_update方法获得List.subList，则不必关心更新，因为两个列表都将指向相同的公共对象（将共享引用）。

如果没有，我会考虑使用Map<Integer, String>个实例而不是List<MyObject>个实例：

Map<Integer, String> list_origin = GET_MyObject1();
Map<Integer, String> list_update = GET_MyObject2();
for(Entry<Integer, String> entry : list_update.entrySet()){
    list_origin.put(entry.getKey(), entry.getValue());
}

Answer 2

总的程序很可能是：

遍历list_update
对于list_update的每个元素，找到与list_origin - id变量匹配的int的相应元素的索引。使用ArrayList.set(index, E)方法更新元素。

总共需要 O(n^2) 费用。

优化：

通过实施MyObject

Comparable<MyObject>

使用list_origin

Collection.sort(list_origin)

然后使用Collections.binarySearch(list, key)方法查找索引目标对象和更新结果

这需要总共花费 O(nlogn) 。

作为一个例子，您的MyObject课程将如下：

class MyObject implements Comparable<MyObject>{
   private int id; 
   private String name;

    public MyObject(int x, String name) {
        this.id = x;
        this.name = name;
    }

    public void updateName(String name)
    {
        this.name = name;
    }


    @Override
    public int compareTo(MyObject o) {
       return Integer.compare(id, o.id);
    }

}

然后更新list_origin：

Collections.sort(list_origin);

for(MyObject obj: list_update)
{
    int indx = Collections.binarySearch(list_origin, obj);
    list_origin.set(indx, obj);
}

使用另一个子集List更新List

2 个答案: