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

Question

Java 8 stream api非常好用,我非常喜欢它.让我紧张的一件事是90%的时间我想作为集合输入作为集合和输出.结果是我必须一直打电话stream()和collect()方法:

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

是否有任何java api可以让我跳过流并直接操作集合(比如linqc#？):

collection.filter(p->p.isCorrect)

Answer 1

是的,使用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在评论中建议的那样,如果您选择在代码中定义此实用程序方法并在需要获取过滤集合的任何位置使用它,则只需将调用委托给collect该实用程序中的方法.您的来电者代码将更加简洁.

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

Answer 2

您可能喜欢使用StreamEx

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

这具有在保持不变性的同时稍微更短暂的优点.

Answer 3

如果您想对藏品进行操作,Guava的FluentIterable是一种方法!

示例(获取10个第一个VIP客户的ID):

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

Answer 4

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

Answer 5

Streams有一个定义良好的架构,你可以阅读很多.在开始这条道路之前,您可能想要了解这一点.

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

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

然后你可以为你的用例做一些棘手的假设.您仍然可以从集合界面打开一个流,但您也可以直接跳入,然后在该句柄的内部打开我想要的流的开头.

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

您的IDE将直接跳到您实现所有内容...只需将所有内容传递回默认实现.

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 + "]");

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