Java -使用流lambdas的多个集合的交集

Question

我有以下功能用于统一多个集合（包括重复元素）：

public static <T> List<T> unify(Collection<T>... collections) {
        return Arrays.stream(collections)
               .flatMap(Collection::stream)
               .collect(Collectors.toList()); 
}

如果集合的交集具有类似签名的函数（使用类型相等），那就太好了。例如：

public static <T> List<T> intersect(Collection<T>... collections) {
     //Here is where the magic happens
}

我找到了一个相交函数的实现，但它不使用流：

public static <T> Set<T> intersect(Collection<? extends Collection<T>> collections) {
    Set<T> common = new LinkedHashSet<T>();
    if (!collections.isEmpty()) {
       Iterator<? extends Collection<T>> iterator = collections.iterator();
       common.addAll(iterator.next());
       while (iterator.hasNext()) {
          common.retainAll(iterator.next());
       }
    }
    return common;
}

是否有任何方法可以利用流实现类似于unify函数的功能？我在java8/StreamAPI方面没有太多经验，因为一些建议会非常有用。

Answer 1

我认为使用Set而不是List可能更有意义(可能这是你问题中的一个错别字):

public static <T> Set<T> intersect(Collection<T>... collections) {
     //Here is where the magic happens
     return (Set<T>) Arrays.stream(collections).reduce(
             (a,b) -> {
                 Set<T> c = new HashSet<>(a);
                 c.retainAll(b);
                 return c;
             }).orElseGet(HashSet::new);
}

Answer 2

虽然很容易将＜code＞retainAll

这意味着线性扫描一个集合并测试所有其他集合中的每个元素是否包含将与为每个集合执行retainAll相当。首先迭代最小集合的加分：

public static <T> Set<T> intersect(Collection<? extends Collection<T>> collections) {
    if(collections.isEmpty()) return Collections.emptySet();
    Collection<T> smallest
        = Collections.min(collections, Comparator.comparingInt(Collection::size));
    return smallest.stream().distinct()
        .filter(t -> collections.stream().allMatch(c -> c==smallest || c.contains(t)))
        .collect(Collectors.toSet());
}

或者，可选地

public static <T> Set<T> intersect(Collection<? extends Collection<T>> collections) {
    if(collections.isEmpty()) return Collections.emptySet();
    Collection<T> smallest
        = Collections.min(collections, Comparator.comparingInt(Collection::size));
    HashSet<T> result=new HashSet<>(smallest);
    result.removeIf(t -> collections.stream().anyMatch(c -> c!=smallest&& !c.contains(t)));
    return result;
}

Answer 3

您可以在一些实用程序类中编写自己的收集器并使用它:

public static <T, S extends Collection<T>> Collector<S, ?, Set<T>> intersecting() {
    class Acc {
        Set<T> result;

        void accept(S s) {
            if(result == null) result = new HashSet<>(s);
            else result.retainAll(s);
        }

        Acc combine(Acc other) {
            if(result == null) return other;
            if(other.result != null) result.retainAll(other.result);
            return this;
        }
    }
    return Collector.of(Acc::new, Acc::accept, Acc::combine, 
                        acc -> acc.result == null ? Collections.emptySet() : acc.result, 
                        Collector.Characteristics.UNORDERED);
}

用法很简单：

Set<T> result = Arrays.stream(collections).collect(MyCollectors.intersecting());

但请注意，收集器不能短路：即使中间结果将是空集合，它仍将处理流的其余部分。

这样的收集器在我免费的StreamEx库中随时可用（参见MoreCollectors.intersecting（））。它适用于上述普通流，但如果您将其与StreamEx（扩展正常流）一起使用，则会变短路：处理实际上可能会提前停止。