您可以在不将值存储在 Java 中的情况下拥有集合吗？

Question

我有一个关于 Java 集合（例如 Set 或 List）的问题。更一般地，您可以在 for-each 循环中使用的对象。是否有任何要求它们的元素实际上必须存储在数据结构中的某个位置，或者它们只能从某种要求中描述并在需要时动态计算？感觉这应该是可以做到的，但我没有看到任何 java 标准集合类做这样的事情。我在这里违反了任何合同吗？

我正在考虑使用这些主要是数学。举例来说，我想要一个代表 1 000 000 以下的所有素数的集合。将它们保存在内存中可能不是一个好主意，而是有一个方法检查特定数字是否在集合中。

我也不是 java 流方面的专家，但我觉得这些应该可以在 java 8 流中使用，因为对象具有非常小的状态（集合中的对象甚至不存在，直到你尝试遍历它们或检查集合中是否存在特定对象）。

是否可以拥有具有几乎无限多元素的集合或迭代器，例如“6*k+1 形式的所有数字”、“10 以上的所有素数”或“此基础上的所有向量”？我正在考虑的另一件事是将两个集合组合起来，例如 1 000 000 以下的所有素数和 2^n-1 形式上的所有整数的并集，并列出 1 000 000 以下的梅森素数。我觉得这样会更容易如果以这种方式完成并且在实际需要元素之前没有显式创建元素，则对某些数学对象进行推理。也许我错了。

这是我写的两个模型类，试图说明我想要做什么。它们的行为并不完全符合我的预期（见输出），这让我觉得我在这里违反了可迭代接口的某种契约或错误地实现了它。如果您看到它，或者在集合框架下甚至允许这种代码，请随时指出我做错了什么。

import java.util.AbstractSet;
import java.util.Iterator;

public class PrimesBelow extends AbstractSet<Integer>{

    int max;
    int size;

    public PrimesBelow(int max) {
        this.max = max;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new SetIterator<Integer>(this);
    }

    @Override
    public int size() {
        if(this.size == -1){
            System.out.println("Calculating size");
            size = calculateSize();
        }else{
            System.out.println("Accessing calculated size");
        }
        return size;
    }

    private int calculateSize() {
        int c = 0;
        for(Integer p: this)
            c++;
        return c;
    }

    public static void main(String[] args){
        PrimesBelow primesBelow10 = new PrimesBelow(10);
        for(int i: primesBelow10)
            System.out.println(i);
        System.out.println(primesBelow10);
    }
}

.

import java.util.Iterator;
import java.util.NoSuchElementException;

public class SetIterator<T> implements Iterator<Integer> {
    int max;
    int current;
    public SetIterator(PrimesBelow pb) {
        this.max= pb.max;
        current = 1;
    }

    @Override
    public boolean hasNext() {
        if(current < max) return true;
        else return false;
    }

    @Override
    public Integer next() {
        while(hasNext()){
            current++;
            if(isPrime(current)){
                System.out.println("returning "+current);
                return current;
            }
        }
        throw new NoSuchElementException();
    }

    private boolean isPrime(int a) {
        if(a<2) return false;
        for(int i = 2; i < a; i++) if((a%i)==0) return false;
        return true;
    }
}

Main function gives the output
returning 2
2
returning 3
3
returning 5
5
returning 7
7
Exception in thread "main" java.util.NoSuchElementException
    at SetIterator.next(SetIterator.java:27)
    at SetIterator.next(SetIterator.java:1)
    at PrimesBelow.main(PrimesBelow.java:38)

edit：在 next() 方法中发现了一个错误。更正它并将输出更改为新的。

Answer 1

好吧，正如您在（现已修复的）示例中看到的那样，您可以使用Iterables/Iterators 轻松完成此操作。与其有一个支持集合，这个例子会更好，只有一个Iterable，它采用您希望计算素数的最大数量。您只需要确保正确处理hasNext() 方法，这样您就不必从next() 抛出不必要的异常。

如今，Java 8 流可以更容易地用于执行这些类型的事情，但没有理由不能拥有一个只是 Iterable 的“虚拟集合”。如果您开始实施Collection，它会变得更加困难，但即便如此，这也不是完全不可能的，具体取决于用例：例如你可以实现检查素数的contains()，但你必须计算它，而且对于大数来说会很慢。

一个不可变且不存储任何值的半无限奇数集的示例（有些复杂）。

public class OddSet implements Set<Integer> {
    public boolean contains(Integer o) {
        return o % 2 == 1;
    }
    public int size() {
        return Integer.MAX_VALUE;
    }
    public boolean add(Integer i) {
        throw new OperationNotSupportedException();
    }

    public boolean equals(Object o) {
        return o instanceof OddSet;
    }
    // etc. etc.
}

Answer 2

正如 DwB 所说，这对于 Java 的 Collections API 是不可能的，因为每个元素都必须存储在内存中。但是，还有另一种选择：这正是实现 Java 的 Stream API 的原因！

Streams 允许您遍历无限数量的未存储在内存中的对象，除非您明确将它们收集到 Collection 中。

来自IntStream#iterate的documentation：

返回由函数 f 迭代应用到初始元素种子产生的无限顺序有序 IntStream，产生由种子、f(seed)、f(f(seed)) 等组成的 Stream。

IntStream 中的第一个元素（位置 0）将是提供的种子。当 n > 0 时，位置 n 处的元素将是函数 f 应用于位置 n - 1 处的元素的结果。

以下是您在问题中提出的一些示例：

public class Test {

    public static void main(String[] args) {
        IntStream.iterate(1, k -> 6 * k + 1);
        IntStream.iterate(10, i -> i + 1).filter(Test::isPrime);
        IntStream.iterate(1, n -> 2 * n - 1).filter(i -> i < 1_000_000);
    }

    private boolean isPrime(int a) {
        if (a < 2) {
            return false;
        }

        for(int i = 2; i < a; i++) {
            if ((a % i) == 0) {
                return false;
            }

            return true;
        }
    }
}