用Java连接两个列表

我需要在Java中加入两个列表。我有一个列表，其中有一个VO，它有一个名称和描述。我有另一个列表，它有相同的VO类型，有名称和地址。“名字”是一样的。我需要用这个VO创建一个列表，它有名称、地址和描述。 VO结构是

public class PersonDetails{
    private String name;
    private String description;
    private String address;
//getters and setters
}

有人能给我建议一下实施它的最佳方法吗？

这取决于：

如果列表包含两个完全相同的数据，则可以按名称对它们进行排序，对它们进行迭代并设置缺少的属性

如果没有，我会将第一个列表放在地图中，名称作为键。然后迭代第二个列表，在映射中查找VO并设置值。 之后，只需将所有值作为列表再次从映射中取出

public List<Vo> merge(List<Vo> list1, List<Vo> list2) {

    Map<String, Vo> tempMap = new HashMap<String, Vo>();

    for (Vo v : list1) {
        tempMap.put(v.name, v);
    }

    for (Vo vv : list2) {

        //The if is in case the 2 lists aren't filled with the same objects            
        if (tempMap.containsKey(vv.name)) {
            tempMap.get(vv.name).description = vv.description;
        } else {
            tempMap.put(vv.name, vv);
        }
    }

    return new ArrayList<Vo>(tempMap.values());

}

公共列表合并（列表1、列表2）{
Map tempMap=newhashmap（）；
对于（VOV:list1）{
tempMap.put（v.name，v）；
}
用于（Vo vv:list2）{
//如果两个列表中没有填充相同的对象，则为if
if（tempMap.containsKey（vv.name））{
tempMap.get（vv.name）.description=vv.description；
}否则{
tempMap.put（vv.name，vv）；
}
}
返回新的ArrayList（tempMap.values（））；
}

如果列表包含完全相同的VO（名称相等），则可以使用此选项

public List<Vo> merge(List<Vo> list1, List<Vo> list2) {

    Collections.sort(list1, new Comparator<Vo>() {

        public int compare(Vo o1, Vo o2) {
            return o1.name.compareTo(o2.name);
        }
    });

    Collections.sort(list2, new Comparator<Vo>() {

        public int compare(Vo o1, Vo o2) {
            return o1.name.compareTo(o2.name);
        }
    });

    for(int i = 0; i < list1.size(); i++){
        list1.get(i).description = list2.get(i).description;
    }

    return list1;

}

公共列表合并（列表1、列表2）{
Collections.sort（list1，newcomparator（）{
公共整数比较（VOO1，VOO2）{
返回o1.name.compareTo（o2.name）；
}
});
Collections.sort（list2，newcomparator（）{
公共整数比较（VOO1，VOO2）{
返回o1.name.compareTo（o2.name）；
}
});
对于（int i=0；i

从列表转到HashMap，使用名称字符串作为键。因此，您可以非常高效地合并数据。

List List=new ArrayList（）；
List<VO> list = new ArrayList<VO>();
for (VO vo1 : vo1List) {
   for (VO vo2 : vo2List) {
    if (vo1.getName().equals(vo2.getName())) {
        VO newVo = new VO();
        newVO.setName(vo1.getName());
        newVO.setDescription(vo1.getDescription());
        newVO.setAddress(vo2.getAddress);
        list.add(newVO);
        break;
    }
}

用于（vo1:vo1列表）{
用于（vo2:vo2列表）{
if（vo1.getName（）.equals（vo2.getName（）））{
VO newVo=新VO（）；
newVO.setName（vo1.getName（））；
newVO.setDescription（vo1.getDescription（））；
newVO.setAddress（vo2.getAddress）；
列表。添加（newVO）；
打破
}
}

}

---

最好事先按名称对两个列表进行排序，这样可以加快双重迭代。

我会按名称将源VO列表的每个列表放入映射中，创建一组双键，对其进行迭代，并将目标VO添加到结果列表中

在示例代码中，VO是目标VO，VOD是仅带说明的源VO，VOA是仅带地址的源VO：

List<VOD> descriptions = ...;
List<VOA> addresses = ...;
Map<String,String> description ByName = new HashMap<String,String>();
for (VOD description : descriptions) {
  descriptionByName.put(description.name, description.description);
}
Map<String,String> addressByName = new HashMap<String,String>();
for (VOA address: addresses ) {
  addressByName.put(address.name, address.address);
}

Set<String> allNames = new HashSet<String>();
allNames.addAll(descriptionByName.keySet());
allNames.addAll(addressByName.keySet());

List<VO> result = new ArrayList<VO>();
for (String name : allNames) {
  VO one = new VO();
  one.name = name;
  one.address = addressByName.get(name)
  one.description = descriptionByName.get(name)
  result.add(one);
}

列表描述=。。。；
列表地址=。。。；
映射描述ByName=新HashMap（）；
用于（视频点播说明：说明）{
descriptionByName.put（description.name，description.description）；
}
Map addressByName=新HashMap（）；
（美国之音地址：地址）{
addressByName.put（address.name，address.address）；
}
Set allNames=new HashSet（）；
allNames.addAll（descriptionByName.keySet（））；
allNames.addAll（addressByName.keySet（））；
列表结果=新建ArrayList（）；
for（字符串名称：AllName）{
voone=新的VO（）；
一.名称=名称；
one.address=addressByName.get（名称）
one.description=descriptionByName.get（名称）
结果：增加（一）；
}

将第一个列表的所有元素放在地图中，然后将第二个列表的内容合并到地图中：

final List<PersonDetails> listWithAddress =
    new ArrayList<PersonDetails>();
final List<PersonDetails> listWithDescription =
    new ArrayList<PersonDetails>();
// fill both lists with data

final Map<String, PersonDetails> map =
    // map sorted by name, change to HashMap otherwise
    // (or to LinkHashMap if you need to preserve the order)
    new TreeMap<String, PersonDetails>();

for(final PersonDetails detailsWithAddress : listWithAddress){
    map.put(detailsWithAddress.getName(), detailsWithAddress);
}
for(final PersonDetails detailsWithDescription : listWithDescription){
    final PersonDetails retrieved =
        map.get(detailsWithDescription.getName());
    if(retrieved == null){
        map.put(detailsWithDescription.getName(),
            detailsWithDescription);
    } else{
        retrieved.setDescription(detailsWithDescription.getDescription());
    }
}

带地址的最终列表=
新的ArrayList（）；
带说明的最终列表=
新的ArrayList（）；
//用数据填充两个列表
最终地图=
//映射按名称排序，否则更改为HashMap
//（如果需要保留订单，请访问LinkHashMap）
新树映射（）；
对于（最终人员详细信息，地址：listWithAddress）{
put（detailsWithAddress.getName（），detailsWithAddress）；
}
用于（最终人员详细信息，说明：列表，说明）{
检索最终个人信息=
get（detailsWithDescription.getName（））；
如果（检索==null）{
map.put（detailsWithDescription.getName（），
详细信息（描述）；
}否则{
检索到.setDescription（detailsWithDescription.getDescription（））；
}
}

您的两个列表大小相同吗？第一个元素中的每个元素都在第二个元素中，反之亦然？列表中的每个元素都是唯一的吗？@Colin HEBERT。两个列表的大小相同。第一个列表中的每个元素都在第二个列表中。例如，第一个列表有一个PersonDetails VO，名称为“John”，描述为“John’s description”。第二个列表中有一个名为“John”和地址为“Street1”的个人详细信息VO。我需要合并这两个列表，这样，我就有了一个新的列表，其名称、地址和描述为“John”、“John description”和“Street1”。好主意，但为什么不将数据从vo2写入vo1，这将节省许多对象创建？@seanizer正是如此，但该示例只是一个简单的示例，让OP了解如何使用双循环来完成此操作。