使用 lambda 过滤通用集合

Question

最后改写问题
------------------------------------------

我必须编写两个泛型方法来过滤泛型类型的集合。

首先从 Collection。

Collection 中的第二个 removeDuplicates 和可选的空/空白。

private <T extends Collection<C>, C extends Object> T  removeDuplicatesFromCollection(T collection, boolean skipNull)
{
    if(collection == null)
    {
        return collection;
    }

    final HashSet<C> tmp = new HashSet<C>();

    for(C element : collection)
    {
        if(element == null && skipNull)
        {
            continue;
        }
        else
        {
            tmp.add(element);
        }
    }

    collection.clear();
    collection.addAll(tmp);

    return collection;
}

我不知道如何解决这个问题。所以我使用 HashSet 来过滤唯一性，清除原始集合并添加 hashset 的所有条目。

首先我尝试通过流式传输和使用 lambda 表达式来解决这个问题，但这里也遇到了需要使用 collect() 处理的问题

首先我通过流式传输和使用 lambda 表达式尝试了这个，但没有 g

它有效，但我相信一定有更好的方法。

第一种方法是从 Collection 中删除重复项和空条目。 我想用 lambda 指令和 apache StringUtils 再次过滤这个列表，但我不知道如何处理收集和泛型类型 T。

private <T extends Collection<String>> T removeDuplicationsFromStringCollection(T collection, boolean skipNull, boolean skipEmpty)
{
    if(collection == null)
    {
        return collection;
    }

    T removedDuplicates = removeDuplicatesFromCollection(collection, skipNull);

    if(removedDuplicates == null || !skipEmpty)
    {
        return removedDuplicates;
    }
    else
    {
        removedDuplicates.().filter(s -> StringUtils.isNotBlank(s)).collect(T::new); <== [X Cannot instantiate the type T ]
    }
}

任何人都可以帮助完成这项工作吗？ 如果有人对第一种方法有更好的解决方案，我也将不胜感激，因为我自己还没有完全满意。

非常感谢

------------[编辑]----

我不知道方法输入的集合类型，输出类型必须是输入类型的集合。 HashSet => 方法 => HashSet => 返回 ArrayList => 方法 => ArrayList => 返回

我不喜欢修改输入集合，但这是我保留集合类型的唯一方法。 问题不是在流式传输期间过滤列表，而是流式结束时的 collect()，并根据输入类型创建泛型类型。 问题是为输出集合保留输入集合的类型。

-------------[改写]-----
让我重新表述并简化这个问题，也许我不应该围绕我想做的事情写这么多。 有任何有用的提示和技巧，但核心问题没有解决

private <T extends Collection> T  doFilter(T pCollection, ....
{
    /** removed code for simplifing **/
    return pCollection.stream()
    /*.filter(....)*/
    .collect(  Collectors.toCollection( ?>>  T  <<?? ) );
}

谁能告诉我如何在泛型类型的 lambda 中收集(Collectors.toCollection(T))？

所以 列表 => doFilter() => 列表
ArrayList => doFilter() => ArrayList
Set => doFilter() => Set
LinkedHashSet => doFilter() => LinkedHashSet

[T => doFilter() => T]
....

Answer 1

使用 java 8 流式 API 确实可以实现更简洁的实现：

public <T extends Collection<Object> T removeDuplicatesFromCollectionAndFilterNull(T collection) {
  return collection.stream()
    .filter(Objects::isNull) // Method Reference to Objects.isNull(object)
    .collect(Collectors.toSet()); // Collect to set to remove duplicates
}

可以使用类似的方法来解决第二个问题。请注意，collect 方法不接受 lambda 来创建集合（并且 T::new 不起作用，因为 Java 不知道该方法是否具有默认构造函数），而是一个 Collector。 This guide might help

Answer 2

你可以在 Stream 上使用 distinct() 方法

 Collection<String> list = Arrays.asList("A", "B", "C", "D", "A", "B", "C");
   // Get collection without duplicate i.e. distinct only
    List<String> distinctElements = 
    list.stream().distinct().collect(Collectors.toList());

这将返回所有不为空的不同元素：

public <T extends Collection<Object>> T removeDuplicatesFromCollection(T collection) {
        return  collection.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());
        }

您也可以将此示例与供应商一起使用：

  public static <T,U extends Collection<T>> U removeDuplicatesFromCollection(Iterable<T> iterable , Supplier<U> collectionType) {
        return  StreamSupport.stream(iterable.spliterator(),false).filter(Objects::nonNull).distinct().collect(Collectors.toCollection(collectionType));
    }
  List<String> strings = Arrays.asList("A","B",null,"B");
        removeDuplicatesFromCollection(strings, ArrayList::new).forEach(System.out::println);

Answer 3

我认为主要问题是要以某种方式知道您正在处理哪种特定类型的集合，因此您可以创建此特定类型的新集合并将过滤后的值添加到其中。改变你的论点是不好的做法，即你不应该修改收到的集合。

所以我会使用Supplier<T> 作为工厂来创建您的特定收藏：

private <T extends Collection<C>, C> T removeDuplicatesFromCollection(
        T collection, 
        boolean skipNull,
        Supplier<? extends T> factory) {

    if (collection == null) return null;

    // Remove duplicates, but keep insertion order (that's what LinkedHashSet is for)
    Set<C> noDuplicates = new LinkedHashSet<>(collection);

    // Remove nulls from the set if the flag is on
    if (skipNull) noDuplicates.removeIf(Objects::isNull);

    // Use the factory to create an empty instance of the collection 
    T newCollection = factory.get();

    // Add the no duplicates set, possibly without nulls
    newCollection.addAll(noDuplicates);

    return newCollection;
}

现在你可以使用上面的方法如下：

List<Integer> list = Arrays.asList(1, 2, 3, null, 5, 6, 1);

ArrayList<Integer> noDupsNoNulls = removeDuplicatesFromCollection(
        list,
        true,
        ArrayList::new); // [1, 2, 3, 5, 6]

---

编辑：如果您已经有对每种具体集合类型执行相同操作的方法，即一个用于List<C>，另一个用于Set<C>，等等，您不需要更改对这些方法的所有调用。您需要做的就是更改它们的实现，以便它们现在指向上面的新方法。

例如，假设你已经有了以下方法：

private <C> HashSet<C> removeDuplicatesFromCollection(
        HashSet<C> collection, 
        boolean skipNull) {

    // .....

}

您可以按如下方式更改：

private <C> HashSet<C> removeDuplicatesFromCollection(
        HashSet<C> collection, 
        boolean skipNull) {

    return removeDuplicatesFromCollection(collection, skipNull, HashSet::new);
}

如果你有 ArrayList 的另一种方法：

private <C> ArrayList<C> removeDuplicatesFromCollection(
        ArrayList<C> collection, 
        boolean skipNull) {

    // .....

}

您可以按如下方式更改：

private <C> ArrayList<C> removeDuplicatesFromCollection(
        ArrayList<C> collection, 
        boolean skipNull) {

    return removeDuplicatesFromCollection(collection, skipNull, ArrayList::new);
}