我有一个关于 Java 集合的问题，例如 Set 或 List。更一般地说，您可以在 for-each 循环中使用的对象。是否要求它们的元素实际上必须存储在数据结构中的某个位置，或者它们是否可以仅根据某种需求进行描述并在需要时即时计算？感觉这应该可以完成，但我没有看到任何 Java 标准集合类做这样的事情。我在这里违反了任何形式的契约(Contract)吗？

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

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

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

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

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)

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

最佳答案

好吧，正如您在(现已修复的)示例中看到的那样，您可以使用 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.
}

关于java - 您可以在不将值存储在 Java 中的情况下拥有集合吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45743690/