如何使用 Stream API 合并然后区分集合？ [复制]

Question

让我们在对象前面加上前缀 equals 实现不是我需要过滤的方式，所以distinct 本身不起作用。

class MyObject {
  String foo;
  MyObject( String foo ) {
    this.foo = foo;
  }
  public String getFoo() { return foo; }
}


Collection<MyObject> listA = Arrays.asList("a", "b", "c").stream().map(MyObject::new)
        .collect(Collectors.toList());

Collection<MyObject> listB = Arrays.asList("b", "d").stream().map(MyObject::new)
        .collect(Collectors.toList());


// magic

如何合并和去重列表，以便结果列表应该是包含“a”、“b”、“c”、“d”的 MyObjects？

注意：这是对我们实际需要去重的方法的简化，这些方法实际上是由 hibernate 加载的实体的复杂 DTO，但此示例应充分展示目标。

Answer 1

JDK 开发人员讨论了此类功能（请参阅JDK-8072723），并且可能包含在 Java-9 中（尽管不能保证）。我开发的StreamEx库已经有这个功能了，大家可以使用：

List<MyObject> distinct = StreamEx.of(listA).append(listB)
                                  .distinct(MyObject::getFoo).toList();

StreamEx 类是一个增强的Stream，它与 JDK Stream 完全兼容，但有许多额外的操作，包括 distinct(Function)，它允许您为不同的操作指定密钥提取器。在内部，它与@fge 提出的解决方案非常相似。

您还可以考虑编写自定义收集器，它将获取不同的对象并将它们存储到列表中：

public static <T> Collector<T, ?, List<T>> distinctBy(Function<? super T, ?> mapper) {
    return Collector.<T, Map<Object, T>, List<T>> of(LinkedHashMap::new,
        (map, t) -> map.putIfAbsent(mapper.apply(t), t), (m1, m2) -> {
            for(Entry<Object, T> e : m2.entrySet()) {
                m1.putIfAbsent(e.getKey(), e.getValue());
            }
            return m1;
        }, map -> new ArrayList<>(map.values()));
}

这个收集器中间将结果收集到Map<Key, Element>，其中Key是提取的Key，Element是对应的流元素。为了确保在所有重复元素中保留第一个出现的元素，使用LinkedHashMap。最后你只需要获取这张地图的values() 并将它们转储到列表中。所以现在你可以写：

List<MyObject> distinct = Stream.concat(listA.stream(), listB.stream())
                                .collect(distinctBy(MyObject::getFoo));

如果您不关心生成的集合是否为列表，您甚至可以删除new ArrayList<>() 步骤（只需使用Map::values 作为完成器）。如果您不关心订单，也可以进行更多简化：

public static <T> Collector<T, ?, Collection<T>> distinctBy(Function<? super T, ?> mapper) {
    return Collector.<T, Map<Object, T>, Collection<T>> of(HashMap::new,
            (map, t) -> map.put(mapper.apply(t), t), 
            (m1, m2) -> { m1.putAll(m2); return m1; }, 
            Map::values);
}

这样的收集器（保留顺序并返回List）在StreamEx 库中也是available。

Answer 2

如果.equals() 不适合您，那么您可能想尝试使用Guava's Equivalence。

假设你的类型是T，你需要实现一个Equivalence<T>；一旦你有了这个，你需要创建一个：

Set<Equivalence.Wrapper<T>>

您将在其中收集您的价值观。然后，假设您的Equivalence<T> 实现是一个名为EQ 的静态变量，添加到这个集合很简单：

coll1.stream().map(EQ::wrap).forEach(set::add);
coll2.stream().map(EQ::wrap).forEach(set::add);

然后要从该集合中获取List<T>，您可以：

final Set<T> unwrapped = set.stream().map(Equivalence.Wrapper::get)
    .collect(Collectors.toSet());

当然，既然在你的 cmets 中你说你可以用一个循环来做到这一点，那么……为什么不继续使用那个循环呢？

如果它有效，请不要修复它......

Answer 3

Collection<MyObject> result = Stream.concat(listA.stream(), listB.stream())
                              .filter(distinct(MyObject::getFoo))
                              .collect(Collectors.toList());

public static <T> Predicate<T> distinct(Function<? super T, Object> keyExtractor) {
        Map<Object, String> seen = new ConcurrentHashMap<>();
        return t -> seen.put(keyExtractor.apply(t), "") == null;
    }

我曾在博客中发现过这个distinct 函数（不记得链接atm）。