java - 在Java中获取一系列整数的迭代器的最短方法

Question

在Java中的一系列整数上获取迭代器的最短方法是什么？换句话说，实现以下内容：

/** 
* Returns an Iterator over the integers from first to first+count.
*/
Iterator<Integer> iterator(Integer first, Integer count);

就像是

(first..first+count).iterator()

Answer 1

此实现没有内存占用。

/**
 * @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>

Answer 2

未经测试。将其映射到“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();
  }
}

Answer 3

如果您真的想要最少的代码，那么 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();
    }
}

Answer 4

使用 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();
    }
}

Answer 5

直接执行您的作业：

List<Integer> ints = new ArrayList<Integer>();
for (int i = 0; i < count; i++) {
    ints.add(first + i);
}

Answer 6

在 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));

Answer 7

它通常被认为是传递Collection和朋友而不是Iterator（参见这个常见问题条目）的好风格，所以我推荐类似的东西

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()在您需要将 an 传递Iterator给您正在使用的任何框架时使用。

更新：显然，这段代码并不懒惰。如果您无法承受存储（可能） 2^32-1 Integers 的额外内存开销，则应该使用不同的解决方案。此外，关于类型的任何内容都不能保证范围会被排序（即使它是基于实现的）。如果您需要保证排序，您可以考虑实现SortedSet并使用TreeSet支持它，但构建范围需要更长的时间。老实说，如果您非常关心正确获取详细信息，那么寻找图书馆可能是值得的。例如， Tapestry 有一个内部版本。