通过具有相同对象类型的 2 个不同列表有效地迭代（Java8）

Question

我有两个列表，其中包含重要数量的对象，每个 N 元素：

List<Foo> objectsFromDB = {{MailId=100, Status=""}, {{MailId=200, Status=""}, {MailId=300, Status=""} ... {MailId=N , Status= N}}

List <Foo> feedBackStatusFromCsvFiles = {{MailId=100, Status= "OPENED"}, {{MailId=200, Status="CLICKED"}, {MailId=300, Status="HARDBOUNCED"} ... {MailId=N , Status= N}} 

小见解： objectFromDB 通过调用 Hibernate 方法检索我的数据库的行。

feedBackStatusFromCsvFiles 调用 CSVparser 方法并解组为 Java 对象。

我的实体类Foo 有所有的setter 和getter。所以我知道基本的想法是使用这样的 foreach：

     for (Foo fooDB : objectsFromDB) {
          for(Foo fooStatus: feedBackStatusFromCsvFiles){
              if(fooDB.getMailId().equals(fooStatus.getMailId())){
                    fooDB.setStatus(fooStatus.getStatus());
                }
               }
            }

就我对初级开发人员的了解而言，我认为这样做是一种非常糟糕的做法？我应该实现一个比较器并使用它来迭代我的对象列表吗？我还应该检查 null 案例吗？

感谢大家的回答！

Answer 1

假设 Java 8 并考虑到 feedbackStatus 可能包含多个具有相同 ID 的元素这一事实。

1. 将列表转换为使用 ID 作为键并具有元素列表的 Map。
2. 迭代列表并使用地图查找所有消息。

代码是：

final Map<String, List<Foo>> listMap = 
objectsFromDB.stream().collect(
      Collectors.groupingBy(item -> item.getMailId())
);

for (final Foo feedBackStatus : feedBackStatusFromCsvFiles) {
        listMap.getOrDefault(feedBackStatus.getMailId(), Colleactions.emptyList()).forEach(item -> item.setStatus(feedBackStatus.getStatus()));
}

Answer 2

您的问题是将 Foo 的最后状态合并到数据库对象中。因此您可以分两步完成，使其更清晰易读。

1. 过滤需要合并的 Foo。

2. 将 Foos 与最后状态合并。

   //because the status always the last,so you needn't use groupingBy methods to create a complex Map.
   Map<String, String> lastStatus = feedBackStatusFromCsvFiles.stream()
           .collect(toMap(Foo::getMailId, Foo::getStatus
                          , (previous, current) -> current));
   //find out Foos in Database that need to merge
   Predicate<Foo> fooThatNeedMerge = it -> lastStatus.containsKey(it.getMailId());
   //merge Foo's last status from cvs.
   Consumer<Foo> mergingFoo = it -> it.setStatus(lastStatus.get(it.getMailId()));
   
   objectsFromDB.stream().filter(fooThatNeedMerge).forEach(mergingFoo);
   

Answer 3

使用集合中的映射来避免嵌套循环。

    List<Foo> aList = new ArrayList<>();
    List<Foo> bList = new ArrayList<>();
    for(int i = 0;i<5;i++){
        Foo foo = new Foo();
        foo.setId((long) i);
        foo.setValue("FooA"+String.valueOf(i));
        aList.add(foo);
        foo = new Foo();
        foo.setId((long) i);
        foo.setValue("FooB"+String.valueOf(i));
        bList.add(foo);
    }

    final Map<Long,Foo> bMap = bList.stream().collect(Collectors.toMap(Foo::getId, Function.identity()));

    aList.stream().forEach(it->{
        Foo bFoo = bMap.get(it.getId());
        if( bFoo != null){
            it.setValue(bFoo.getValue());
        }
    });

唯一的其他解决方案是让 DTO 层返回 MailId->Foo 对象的映射，因为您可以使用 CVS 列表进行流式传输，并简单地查找 DB Foo 对象。否则，对两个列表进行排序或迭代的代价不值得在性能时间上进行权衡。前面的陈述一直成立，直到它最终导致平台上的内存限制，直到那时让垃圾收集器完成它的工作，而您尽可能轻松地完成您的工作。

Answer 4

鉴于您的列表可能包含数以万计的元素，您应该担心简单的嵌套循环方法会太慢。它肯定会执行比它需要做的更多的比较。

如果内存相对丰富，那么最快的合适方法可能是从您的一个列表中形成一个从mailId 到对应Foo 的映射，有点像@MichaelH 建议的那样，并使用它匹配mailIds。但是，如果 mailId 值在一个或两个列表中不一定是唯一的，那么您将需要一些与 Michael 的特定方法不同的东西。即使mailIds 在两个列表中肯定是唯一的，只形成一个映射会更有效率。

对于最一般的情况，您可能会这样做：

// The initial capacity is set (more than) large enough to avoid any rehashing
Map<Long, List<Foo>> dbMap = new HashMap<>(3 * objectFromDb.size() / 2);

// Populate the map
// This could be done more effciently if the objects were ordered by mailId,
// which perhaps the DB could be enlisted to ensure.
for (Foo foo : objectsFromDb) {
    Long mailId = foo.getMailId();
    List<Foo> foos = dbMap.get(mailId);

    if (foos == null) {
        foos = new ArrayList<>();
        dbMap.put(mailId, foos);
    }
    foos.add(foo);
}

// Use the map
for (Foo fooStatus: feedBackStatusFromCsvFiles) {
    List<Foo> dbFoos = dbMap.get(fooStatus.getMailId());

    if (dbFoos != null) {
        String status = fooStatus.getStatus();

        // Iterate over only the Foos that we already know have matching Ids
        for (Foo fooDB : dbFoos) {
            fooDB.setStatus(status);
        }
    }
}

---

另一方面，如果您的空间有限，因此创建地图是不可行的，但是重新排序两个列表是可以接受的，那么您仍然应该通过首先对两个列表进行排序来提高性能。大概您会为此目的使用Collections.sort() 和适当的Comparator。然后，您将在每个列表上获得一个Iterator，并使用它们在两个列表上进行协作迭代。我没有提供代码，但它会让人想起合并排序的合并步骤（但这两个列表实际上并未合并；您只需将状态信息从一个复制到另一个）。但这只有在 feedBackStatusFromCsvFiles 和 feedBackStatusFromCsvFiles 中的 mailIds 都不同时才有意义，否则整个任务的预期结果无法很好地确定。