在 Java 中获取一系列整数的迭代器的最短方法是什么？换句话说，实现以下内容：
/**
* Returns an Iterator over the integers from first to first+count.
*/
Iterator<Integer> iterator(Integer first, Integer count);
类似
(first..first+count).iterator()
【问题讨论】：
此实现没有内存占用。
/**
* @param begin inclusive
* @param end exclusive
* @return list of integers from begin to end
*/
public static List<Integer> range(final int begin, final int end) {
return new AbstractList<Integer>() {
@Override
public Integer get(int index) {
return begin + index;
}
@Override
public int size() {
return end - begin;
}
};
}
在 Java 8 及更高版本中，您可以简单地说：
IntStream.range(begin, end).iterator() // returns PrimitiveIterator.OfInt
或者如果您需要盒装版本：
IntStream.range(begin, end).boxed().iterator() // returns Iterator<Integer>
【讨论】：
java.util.Collection 定义的那样。特别是，如果有人调用它的“破坏性”方法之一，如add() 或remove()，它会抛出UnsupportedOperationException。更多详细信息，请参见java.util.AbstractList 的 JavaDoc。
get() 方法应该检查其参数是否在有效范围内，如果不是（例如负数或大于大小）则抛出 IndexOutofBoundsException。
begin 和end），但它是不变的。
未经测试。将其映射到“min, count”作为练习留给读者。
public class IntRangeIterator implements Iterator<Integer> {
private int nextValue;
private final int max;
public IntRangeIterator(int min, int max) {
if (min > max) {
throw new IllegalArgumentException("min must be <= max");
}
this.nextValue = min;
this.max = max;
}
public boolean hasNext() {
return nextValue <= max;
}
public Integer next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return Integer.valueOf(nextValue++);
}
public void remove() {
throw new UnsupportedOperationException();
}
}
【讨论】：
如果您真的想要最少的代码，那么 Bombe 的答案就可以了。但是，它无缘无故地吸收内存。如果你想自己实现它，它会是这样的：
import java.util.*;
public class IntegerRange implements Iterator<Integer>
{
private final int start;
private final int count;
private int position = -1;
public IntegerRange(int start, int count)
{
this.start = start;
this.count = count;
}
public boolean hasNext()
{
return position+1 < count;
}
public Integer next()
{
if (position+1 >= count)
{
throw new NoSuchElementException();
}
position++;
return start + position;
}
public void remove()
{
throw new UnsupportedOperationException();
}
}
【讨论】：
使用 guava 框架的示例。请注意，这不会实现集合（尽管您必须阅读 ContiguousSet 实现来验证这一点）。
import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.DiscreteDomains;
class RangeIterator {
public Iterator<Integer> range(int start, int length) {
assert length > 0;
Range<Integer> dim_range = Ranges.closedOpen(start, start + length);
DiscreteDomain<Integer> ints = DiscreteDomains.integers();
ContiguousSet<Integer> dim = dim_range.asSet(ints);
return dim.iterator();
}
}
【讨论】：
Iterator<Integer> range = Ranges.closedOpen(start, end).asSet(DiscreteDomains.integers()).iterator();
Range#asSet(DiscreteDomain) 方法 is deprecated and has been removed in Guava 16。
Iterator<Integer> range = ContiguousSet.create(Ranges.closedOpen(start, end), DiscreteDomains.integers()).iterator();
直接完成你的作业：
List<Integer> ints = new ArrayList<Integer>();
for (int i = 0; i < count; i++) {
ints.add(first + i);
}
【讨论】：
在 java 8 中使用流 API 的示例：
int first = 0;
int count = 10;
Iterator<Integer> it = IntStream.range(first, first + count).iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
没有迭代器，它可能是：
int first = 0;
int count = 10;
IntStream.range(first, first + count).forEach(i -> System.out.println(i));
【讨论】：
通常认为传递Collection 和朋友而不是Iterator（见this FAQ entry）是一种很好的风格，所以我推荐类似
public final class IntegerRange implements Set<Integer> {
final LinkedHashSet<Integer> backingList;
public IntegerRange(final int start, final int count) {
backingList = new LinkedHashSet(count, 1.0f);
for (int i=0; i < count; i++) {
backingList.set(i, start + i);
}
}
/** Insert a bunch of delegation methods here */
}
然后当您需要将Iterator 传递给您正在使用的任何框架时，只需使用.iterator()。
更新：显然，这段代码并不懒惰。如果您负担不起存储（可能）2^32-1 Integers 的额外内存开销，您应该使用不同的解决方案。此外，关于类型的任何内容都不能保证范围会被排序（即使它是基于实现的）。如果您需要保证排序，您可以考虑实现SortedSet 并用TreeSet 支持它，但构建范围需要更长的时间。老实说，如果您非常关心正确获取详细信息，那么寻找图书馆可能是值得的。例如，Tapestry 有一个internal version。
【讨论】：