优雅地组合两个列表的元素，使它们在某个属性值中是唯一的？

Question

假设我有这个Java 8代码：

public class Foo {
    private long id;
    public getId() {
        return id;
    }

    //--snip--
}


//Somewhere else...

List<Foo> listA = getListA();
List<Foo> listB = getListB();

List<Foo> uniqueFoos = ???;

在列表中

当然有简单的老迭代，但我认为应该有更优雅的东西(可能涉及流，但不是强制性的)，但我不太明白...

我可以想到一些好的解决方案，包括覆盖equals（）方法以基本上返回id==other.id；并使用Set或（）。不幸的是，我不能覆盖equals（），因为对象相等性不能改变。

实现这一目标的明确有效方法是什么？

Answer 1

你可以写这个。由于filter（）和使用Set来存储遇到的id，这将跳过具有相同id的第二个和下一个元素：

    Set<Long> ids = new HashSet<>();
    List<Foo> uniqueFoos = Stream.concat(getListA().stream(), getListB().stream())
                                 .filter(f -> ids.add(f.getId()))
                                 .collect(Collectors.toList());

这不是一个完整的流解决方案，但它是相当直接和可读性。

Answer 2

像这样的事情就可以了。

 List<Foo> uniqueFoos = Stream.concat(listA.stream(), listB.stream())
                              .filter(distinctByKey(Foo::getId))
                              .collect(Collectors.toList());


 public <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
  }

Answer 3

您可以使用Collectors.toMap：

Collection<Foo> uniqueFoos = Stream.concat(listA.stream(), listB.stream())
    .collect(Collectors.toMap(
        Foo::getId,
        f -> f,
        (oldFoo, newFoo) -> oldFoo))
    .values();

如果您需要列表而不是集合，只需执行以下操作：

List<Foo> listUniqueFoos = new ArrayList<>(uniqueFoos);

如果还需要保留元素的相遇顺序，则可以使用＜code＞收集器的重载版本。toMap接受返回地图的供应商：

Collection<Foo> uniqueFoos = Stream.concat(listA.stream(), listB.stream())
    .collect(Collectors.toMap(
        Foo::getId,
        f -> f,
        (oldFoo, newFoo) -> oldFoo,
        LinkedHashMap::new))
    .values();

我认为值得添加一个非流变量：

Map<Long, Foo> map = new LinkedHashMap<>();
listA.forEach(f -> map.merge(g.getId(), f, (oldFoo, newFoo) -> oldFoo));
listB.forEach(f -> map.merge(g.getId(), f, (oldFoo, newFoo) -> oldFoo));

Collection<Foo> uniqueFoos = map.values();

这可以重构为通用方法以不重复代码：

static <T, K> Collection<T> uniqueBy(Function<T, K> groupBy, List<T>... lists) {
    Map<K, T> map = new LinkedHashMap<>();
    for (List<T> l : lists) {
        l.forEach(e -> map.merge(groupBy.apply(e), e, (o, n) -> o));
    }
    return map.values();
}

您可以按如下方式使用它:

Collection<Foo> uniqueFoos = uniqueBy(Foo::getId, listA, listB);

此方法使用 Map.merge 方法。