Java 流参数限制无限制（MongoDB 不一致）

Question

我有一个方法，它返回项目列表并将限制（由Stream#limit 使用）作为参数：

public List<Integer> getItems(Long limit) {
    return IntStream.range(1, 10)
            .limit(limit)
            .boxed()
            .collect(Collectors.toList());
}  

如何设置参数取所有项目（无限制）？

我的尝试：

    Long limit5 = 5L;
    System.out.println("With limit 5:" + getItems(limit5));
    // works fine: 5 items

    Long noLimitZero = 0L;
    System.out.println("Without limit (zero): " + getItems(noLimitZero));
    // why 0 mean "no items" instead of "all items"

   Long noLimitNegative = -1L;
    System.out.println("Without limit (negative number): " + getItems(noLimitNegative));
    // IllegalArgumentException

    Long noLimitNull = null;
    System.out.println("Without limit (null): " + getItems(noLimitNull));
    // NullPointerException

传递Long.MAX_VALUE 不是解决方案。

MongoDB 不一致

例如MongoDB的FindIterable#limit可以以0或null为无限制。

public List<Integer> getItems(Long limit) {
    MongoDatabase mongo = new MongoClient().getDatabase("example");
    MongoCollection<Document> documents = mongo.getCollection("items");
    FindIterable<Document> founded = documents.find();
    List<Integer> items = new ArrayList<>();
    for (Document doc : founded.limit(limit.intValue())) {
        items.add(doc.getInteger("number"));
    }
    return items;
}

方法之间的这种不一致会导致不兼容，例如一个接口与方法 List<Integer> getItems(Long limit) 和两个实现：在内存中和 MongoDB。

保留方法 Stream#skip 和 FindIterable#skip 的一致性。

          --------------------------
          | Java       | Mongo     |
------------------------------------
limit = 0 | none items | all items |
------------------------------------
skip = 0  | none skip  | none skip |
------------------------------------

使用 Stream#limit 重构方法

我想没有办法将“无限制”参数传递给Stream#limit，所以我必须重构这个方法以将“限制”和0或null或-1作为“无限制”。

public static List<Integer> getItems(Long limit) {
    if (limit == null || limit == 0 || limit == -1) {
        return IntStream.range(1, 10)
                .boxed()
                .collect(Collectors.toList());
    } else {
        return IntStream.range(1, 10)
                .limit(limit)
                .boxed()
                .collect(Collectors.toList());
    }
}

或者：

public static List<Integer> getItems(Long limit) {
    IntStream items = IntStream.range(1, 10);
    if (limit != null && limit != 0 && limit != -1) {
        items = items.limit(limit);
    }
    return items.boxed()
            .collect(Collectors.toList());
}

有没有更好的方法来实现方法limit之间的一致性？

Answer 1

因此，您尝试做的事情存在多层问题。

您说“实用性不是论据”，这很好，但我要指出 Long.MAX_VALUE 确实超过了地球上的原子数量，因此您获得的条目数量可能比来自数据库真的很小。更不用说您继续将这些数据收集到一个列表中，这样您也可能在自己的应用程序中遇到内存问题。

所以第二件事是limit()的语义是它对条目的数量施加了一个固定的限制，而“无穷大”不是一个固定的限制；因此limit() 不是您要找的。​​p>

第三，您似乎正在寻找一种解决方法，因此我们有一个您可以使用的模式，那就是维护您自己的计数器。你想要的是类似AtomicBigInteger 的东西，它在JDK but is shown here 中不存在。

所以你要做的就是像这样创建一个Predicate

class BelowValue<T> implements Predicate<T> {
    BigInteger limit = BigInteger.ZERO;
    AtomicBigInteger counter = new AtomicBigInteger();

    public BelowValue(BigInteger limit) {
        this.limit = limit;
    }        
    public BelowValue() {}

    public boolean test(T ignored) {
        // short circuit on zero
        if (BigInteger.ZERO.compareTo(limit) == 0) { return true; }

        // check actual condition
        return  counter.incrementAndGet().compareTo(limit) > 0;
    }
}

然后你可以在你的流中使用它（Java 8）

Predicate<T> filter = new BelowValue<>(limit);
return stream
    .filter(filter)
    .boxed()
    .collect(Collectors.toList());

但请注意，filter 不是短路操作，因此如果您有一个无限流，这将不会终止（如果您的流比限制长得多，效率会非常低大小）。

Java 9 的 takeWhile 是短路的，因此您可以在上面的示例中将其替换为 filter。