将两个对象列表合并到具有值的地图中，作为Java 8中的不同对象

Question

我有两个相同类型“MyInfoObject”的列表（例如A和B)，这样：

public class MyInfoObject {
  private Long id;
  private String signature;

  public MyInfoObject(Long id, String signature) {
      super();
      this.id = id;
      this.signature = signature;
  }
}

我想创建这两个列表的映射，以便列表a的所有ID和具有相同签名的列表B的所有ID创建一个类型为“bucketoFaandB”的桶：

public class BucketOfAandB {
  private List<Long> aIds ;
  private List<Long> bIds ;

  public BucketOfAandB(List<Long> aIds, List<Long> bIds) {
    super();
    this.aIds = aIds;
    this.bIds = bIds;
  }
 }

因此，我的输出将是map ，其中key是签名

我的建议是：

    List<MyInfoObject> aList = new ArrayList<>();
    aList.add(new MyInfoObject(1l, "a"));
    aList.add(new MyInfoObject(2l, "d"));
    aList.add(new MyInfoObject(3l, "b"));
    aList.add(new MyInfoObject(4l, "a"));
    aList.add(new MyInfoObject(5l, "a"));
    aList.add(new MyInfoObject(6l, "c"));
    aList.add(new MyInfoObject(7l, "a"));
    aList.add(new MyInfoObject(8l, "c"));
    aList.add(new MyInfoObject(9l, "b"));
    aList.add(new MyInfoObject(10l, "d"));

    List<MyInfoObject> bList = new ArrayList<>();
    bList.add(new MyInfoObject(11l, "a"));
    bList.add(new MyInfoObject(21l, "e"));
    bList.add(new MyInfoObject(31l, "b"));
    bList.add(new MyInfoObject(41l, "a"));
    bList.add(new MyInfoObject(51l, "a"));
    bList.add(new MyInfoObject(61l, "c"));
    bList.add(new MyInfoObject(71l, "a"));
    bList.add(new MyInfoObject(81l, "c"));
    bList.add(new MyInfoObject(91l, "b"));
    bList.add(new MyInfoObject(101l, "e"));

在这种情况下，我的输出将是：

{
    a= BucketOfAandB[aIds=[1, 4, 5, 7], bIds=[11, 41, 51, 71]],
    b= BucketOfAandB[aIds=[3, 9], bIds=[31, 91]],
    c= BucketOfAandB[aIds=[6, 8], bIds=[61, 81]],
    d= BucketOfAandB[aIds=[2, 10], bIds=null],
    e= BucketOfAandB[aIds=null, bIds=[21, 101]],
}

我想用Java 8的流来做这件事。

我想出的一个办法是：

• 从列表创建映射 > ,say abuckets
• 迭代bList并创建结果映射 依据
  • 2A。将具有相同签名的aBuckets的列表设置为结果列表，将其从aBuckets
  中删除
  • 2b。将blist元素添加到所需签名桶

  我想知道一个更好的方法来实现这个使用Java 8的流。

  提前道谢！

  编辑：我试过使用流，但对实现不是很满意。以下是我的逻辑：

  Map<String, BucketOfAandB> resultmap  = new HashMap<>();
  
      // get ids from aList grouped by signature
      Map<String, List<Long>> aBuckets = aList.stream().collect(Collectors.groupingBy(MyInfoObject::getSignature,
              Collectors.mapping(MyInfoObject::getId, Collectors.toList())));
  
      // iterate bList and add it to bucket of its signature
      bList.forEach(reviewInfo -> {
          BucketOfAandB bucket = resultmap.get(reviewInfo.getSignature());
  
          if(null ==  bucket) {
              bucket = new BucketOfAandB();
              resultmap.put(reviewInfo.getSignature(), bucket);
  
              List<Long> sourceReviewBucket =  aBuckets.remove(reviewInfo.getSignature());
              if(null !=sourceReviewBucket) {
                  bucket.setaIds(sourceReviewBucket);
              }
          }
          bucket.addToB(reviewInfo.getId());
      });
  
      Map<String, BucketOfAandB> result = aBuckets.entrySet().stream()
              .collect(Collectors.toMap(Map.Entry::getKey, e -> new BucketOfAandB(e.getValue(), null)));
  
      resultmap.putAll(result);
  

Answer 1

如果您将getter添加到MyInfoObject中，并使BucketOfaandb惰性初始化其列表（即没有构造函数），如下所示：

public class BucketOfAandB {
    private List<Long> aIds;
    private List<Long> bIds;
    public void addAId(Long id) {
        if (aIds == null) {
            aIds = new ArrayList<>();
        }
        aIds.add(id);
    }
    public void addBId(Long id) {
        if (bIds == null) {
            bIds = new ArrayList<>();
        }
        bIds.add(id);
    }
}

您可以在保留您意图的语义的情况下，只需三行即可完成此操作：

Map<String, BucketOfAandB> map = new HashMap<>();
aList.forEach(o -> map.computeIfAbsent(o.getSignature(), s -> new BucketOfAandB())
  .addAId(o.getId()));
bList.forEach(o -> map.computeIfAbsent(o.getSignature(), s -> new BucketOfAandB())
  .addBId(o.getId()));

如果您使用的是并行流，synchronize将添加方法，这实际上不会增加性能损失，因为它只是桶上的潜在冲突。