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

1> Saintali..：

---

此实现没有内存占用.

/**
 * @param begin inclusive
 * @param end exclusive
 * @return list of integers from begin to end
 */
public static List range(final int begin, final int end) {
    return new AbstractList() {
            @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

---

虽然列表本身很短，但它返回一个List而不是Iterable / Iterator，后者提供了更多的接口方法。这些未在此处实现，如果在“无法预料”的上下文中使用列表实例，则可能导致意外结果。因此，您可以说此实现违反了List接口协定。同样，在AbstractList中实现迭代器并不像它可能的那么简单，并且使用了比实例更多的实例变量，因此内存占用量很小。因此，我宁愿直接实现Iterable / Iterator。

2> Joachim Saue..：

---

未经测试.将其映射到"min,count"是留给读者的练习.

public class IntRangeIterator implements Iterator {
  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();
  }
}

3> Jon Skeet..：

---

如果你真的想要最短的代码量,那么Bombe的答案就可以了.然而,它没有充分理由吸引记忆.如果你想自己实现它,它将是这样的:

import java.util.*;

public class IntegerRange implements Iterator
{
    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();
    }
}

4> Lee..：

---

使用番石榴框架的一个例子.请注意,这不会实现集合(尽管您必须阅读ContiguousSet实现以验证它).

import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.DiscreteDomains;

class RangeIterator { 

    public Iterator range(int start, int length) {
        assert length > 0;
        Range dim_range = Ranges.closedOpen(start, start + length);
        DiscreteDomain ints = DiscreteDomains.integers();
        ContiguousSet dim = dim_range.asSet(ints);
        return dim.iterator();
    }
}