Java 8 - 省略了繁琐的收集方法

Question

Java 8 流 api 是一个非常好的功能，我非常喜欢它。让我紧张的一件事是，90% 的时间我都希望将输入作为集合，将输出作为集合。结果是我必须一直调用stream() 和collect() 方法：

collection.stream().filter(p->p.isCorrect()).collect(Collectors.toList());

是否有任何 java api 可以让我跳过流并直接对集合进行操作（如 c# 中的linq？）：

collection.filter(p->p.isCorrect)

Answer 1

使用cyclops-react，您有多种选择。

我们可以利用惰性扩展集合

  CollectionX<String> collection = ListX.of("hello","world");
  CollectionX<String> filtered = collection.filter(p->p.isCorrect());

支持可变、不可变和持久的扩展集合。集合上的函数操作是惰性的（即表现得像可重放的流），并且仅在首次访问时实现。

我们可以利用强大的扩展 Stream 类型

  ReactiveSeq.fromIterable(collection)
             .filter(p->p.isCorrect())
             .toList();

[披露我是 cyclops-react 的主要开发者]

Answer 2

如果你想对集合进行操作Guava's FluentIterable是一种方法！

示例（获取 10 位第一个 vip 客户的 ID）：

FluentIterable
       .from(customers)
       .filter(customer -> customer.isVIP())
       .transform(Client::getId)
       .limit(10);

Answer 3

如果您需要过滤视图而不修改原始集合，请考虑 Guava 的Collections2.filter()。

Answer 4

如果您愿意使用第三方库，您可以使用Eclipse Collections，它具有丰富的 API，可直接在集合下使用。您的示例可以使用 Eclipse Collections 编写如下。

collection.select(p->p.isCorrect)
collection.select(MyClass::isCorrect)

注意：我是 Eclipse Collections 的提交者。

Answer 5

是的，有几个库可以解决 Java 8 的流冗长问题。不完整的列表：

• jOOL
• javaslang
• StreamEx

我更喜欢 jOOL。我在上一个项目中一直在使用它。其他我知道但我没有真正使用过，所以我不能给你一个印象。

您使用 jOOL 的示例是：

Seq.seq(collection).filter(p->p.isCorrect()).toList();

Answer 6

我也认为 Stream API 很好，但对于简短的操作来说很冗长。我在几个项目中使用了这些实用方法：

import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Functions {

    public static <T,V> List<V> map(final List<T> in, final Function<T, V> function) {
        return in == null ? null : map(in.stream(), function);
    }

    public static <T,V> List<V> map(final Stream<T> in, final Function<T, V> function) {
        return in == null ? null : in
            .map(function)
            .collect(Collectors.toList());
    }

    public static <T> List<T> filter(final List<T> in, final Predicate<T> predicate) {
        return in == null ? null : filter(in.stream(), predicate);
    }

    public static <T> List<T> filter(final Stream<T> in, final Predicate<T> predicate) {
        return in == null ? null : in
            .filter(predicate)
            .collect(Collectors.toList());
    }
}

这让我可以做例如

List<String> wrapped = Functions.map(myList, each -> "[" + each + "]");

通常我也会静态导入该方法。

Answer 7

是的，使用Collection#removeIf(Predicate)：

删除此集合中满足给定谓词的所有元素。

请注意，它会更改给定的集合，而不是返回一个新集合。但是您可以创建集合的副本并对其进行修改。另请注意，谓词需要被否定才能充当过滤器：

public static <E> Collection<E> getFilteredCollection(Collection<E> unfiltered,
                                                      Predicate<? super E> filter) {
    List<E> copyList = new ArrayList<>(unfiltered);

    // removeIf takes the negation of filter 
    copyList.removeIf(e -> { return !filter.test(e);});  

    return copyList;
}

但正如@Holger 在 cmets 中所建议的那样，如果您选择在代码中定义此实用程序方法并在需要获得过滤集合的任何地方使用它，那么只需将调用委托给该实用程序中的 collect 方法即可。你的调用者代码会更简洁。

public static <E> Collection<E> getFilteredCollection(Collection<E> unfiltered,
                                                      Predicate<? super E> filter) {
   return unfiltered.stream()
                    .filter(filter)
                    .collect(Collectors.toList());
}

Answer 8

你可以试试这个，来自 guava 库。它似乎比 Stream 方法更简洁。

 ImmutableList.copyOf(Iterables.filter(collection, MyClass::isCorrect));

有关该技术的讨论，请参阅 Google Collections (Guava Libraries): ImmutableSet/List/Map and Filtering。

Answer 9

您可能喜欢使用StreamEx

StreamEx.of(collection).filter(PClass::isCorrect).toList();

这样的优点是在保持不变性的同时稍微简短一些。

Answer 10

Streams 有一个定义明确的架构，which you can read a lot about。在你开始这条路之前，你可能想了解一下。

但是为什么不实现一个集合，它实现了一个类似的流接口，为你包装了代码呢？

public class StreamableCollection implements Collection, Stream {
...
}

然后你可以为你的用例做一些棘手的假设。你仍然可以从集合界面打开一个流，但你也可以直接跳进去，然后在我想的那个手柄的内部打开流。

    streamableCollection cs = new streamableCollection();
    cs.filter();
    cs.stream();

您的 IDE 将让您正确实现所有内容...只需将所有内容传回默认实现即可。