如何在Java中生成连续整数的列表或数组？

有没有产生一个简短而亲切的方式List<Integer>，或者可能是 Integer[]或int[]，与一些连续值start值的end价值？

也就是说，以下内容比以下内容短，但等于¹：

void List<Integer> makeSequence(int begin, int end) {
  List<Integer> ret = new ArrayList<>(end - begin + 1);
  for (int i=begin; i<=end; i++) {
    ret.add(i);
  }
  return ret;  
}

番石榴的用途很好。

更新：

绩效分析

由于使用本机Java 8和第三方库都可以很好地回答这个问题，所以我认为我应该测试所有解决方案的性能。

第一个测试只是[1..10]使用以下方法测试创建包含10个元素的列表：

• classicArrayList：我问题中上面给出的代码（与adarshr的回答基本相同）。
• eclipseCollections：下面的Donald答案中使用Eclipse Collections 8.0 给出的代码。
• guavaRange：下面的daveb答案中给出的代码。从技术上讲，这并不会创建List<Integer>而是ContiguousSet<Integer>-，但是由于它Iterable<Integer>是按顺序实现的，因此大多数情况下可以实现我的目的。
• intStreamRange：下面弗拉基米尔的答案中给出的代码，它使用IntStream.rangeClosed()-在Java 8中引入的。
• streamIterate：下面的Catalin答案中给出的代码，该代码也使用IntStreamJava 8中引入的功能。

以下是上述所有大小为10的列表的结果，以千千克/秒为单位（数字越大越好）：

...再一次列出大小为10,000的列表：

最后一张图表是正确的-除Eclipse和Guava之外的解决方案太慢，甚至无法获得单个像素条！快速的解决方案是其他解决方案的10,000到20,000 倍。

当然，这里发生的是番石榴和日食解决方案实际上并没有实现任何类型的10,000个元素列表-它们只是围绕起点和终点的固定大小包装器。在迭代过程中根据需要创建每个元素。由于我们实际上没有在此测试中进行迭代，因此会延迟成本。所有其他解决方案实际上在内存中实现了完整列表，并在仅创建基准中付出了沉重的代价。

让我们做一些更现实的事情，并迭代所有整数，将它们求和。因此，对于IntStream.rangeClosed变体，基准看起来像：

@Benchmark
public int intStreamRange() {
    List<Integer> ret = IntStream.rangeClosed(begin, end).boxed().collect(Collectors.toList());  

    int total = 0;
    for (int i : ret) {
        total += i;
    }
    return total;  
}

尽管非实体化解决方案仍然是最快的，但这里的图片变化很大。这是长度= 10：

...且长度= 10,000：

对许多元素的长时间迭代使事情变得更加平坦，但是即使在进行10,000个元素测试时，日食和番石榴的速度仍是其两倍以上。

因此，如果您真的想要List<Integer>，eclipse集合似乎是最佳选择-但是，如果您以更原生的方式使用流（例如，忘记.boxed()并进行原始域的缩减），则最终可能会比所有这些更快变体。

¹也许是错误处理的例外，例如，如果end< begin，或者大小超过某些实现或JVM限制（例如，大于的数组）2^31-1。

使用Java 8，它是如此简单，因此它不再需要单独的方法：

List<Integer> range = IntStream.rangeClosed(start, end)
    .boxed().collect(Collectors.toList());

好吧，这只班轮可能有资格（使用番石榴范围）

ContiguousSet<Integer> integerList = ContiguousSet.create(Range.closedOpen(0, 10), DiscreteDomain.integers());
System.out.println(integerList);

这不会创建List<Integer>，而是ContiguousSet提供了许多相同的功能，尤其是实现后Iterable<Integer>，foreach实现方式与相同List<Integer>。

在旧版本中（Guava 14之前的某个地方），您可以使用以下命令：

ImmutableList<Integer> integerList = Ranges.closedOpen(0, 10).asSet(DiscreteDomains.integers()).asList();
System.out.println(integerList);

两者都会产生：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

以下一线Java 8版本将生成[1，2，3 ... 10]。of iterate的第一个arg 是序列中的第一个nr，of 的第一个arg limit是最后一个数字。

List<Integer> numbers = Stream.iterate(1, n -> n + 1)
                              .limit(10)
                              .collect(Collectors.toList());

您可以使用Eclipse Collections中的Interval类。

List<Integer> range = Interval.oneTo(10);
range.forEach(System.out::print);  // prints 12345678910

该Interval班是懒惰的，所以不存储所有的值。

LazyIterable<Integer> range = Interval.oneTo(10);
System.out.println(range.makeString(",")); // prints 1,2,3,4,5,6,7,8,9,10

您的方法将可以按以下方式实现：

public List<Integer> makeSequence(int begin, int end) {
    return Interval.fromTo(begin, end);
}

如果您希望避免将整数作为Integers装箱，但仍希望使用列表结构，那么可以使用Eclipse Collections中的IntListwith IntInterval。

public IntList makeSequence(int begin, int end) {
    return IntInterval.fromTo(begin, end);
}

IntList有方法sum()，min()，minIfEmpty()，max()，maxIfEmpty()，average()和median()可用的接口。

为清楚起见更新：2017年11月27日

An Interval是一个List<Integer>，但它是惰性的并且是不变的。这对于生成测试数据非常有用，尤其是在您处理大量集合时。如果你愿意，你可以在一个时间间隔轻松复制到List，Set或Bag如下：

Interval integers = Interval.oneTo(10);
Set<Integer> set = integers.toSet();
List<Integer> list = integers.toList();
Bag<Integer> bag = integers.toBag();

An IntInterval是ImmutableIntList延伸的IntList。它还具有转换器方法。

IntInterval ints = IntInterval.oneTo(10);
IntSet set = ints.toSet();
IntList list = ints.toList();
IntBag bag = ints.toBag();

An Interval和an IntInterval没有相同的equals合同。

Eclipse Collections 9.0的更新

现在，您可以从原始流创建原始集合。有withAll和ofAll方法取决于您的喜好。如果您好奇，请解释为什么我们都在这里。这些方法适用于可变且不变的Int / Long / Double列表，集合，袋子和堆栈。

Assert.assertEquals(
        IntInterval.oneTo(10),
        IntLists.mutable.withAll(IntStream.rangeClosed(1, 10)));

Assert.assertEquals(
        IntInterval.oneTo(10),
        IntLists.immutable.withAll(IntStream.rangeClosed(1, 10)));

注意：我是Eclipse Collections的提交者

这是我使用Core Java可获得的最短的时间。

List<Integer> makeSequence(int begin, int end) {
  List<Integer> ret = new ArrayList(end - begin + 1);

  for(int i = begin; i <= end; i++, ret.add(i));

  return ret;  
}

您可以使用番石榴范围

您可以SortedSet通过使用获得

ImmutableSortedSet<Integer> set = Ranges.open(1, 5).asSet(DiscreteDomains.integers());
// set contains [2, 3, 4]

这是我能找到的最短的。

清单版本

public List<Integer> makeSequence(int begin, int end)
{
    List<Integer> ret = new ArrayList<Integer>(++end - begin);

    for (; begin < end; )
        ret.add(begin++);

    return ret;
}

阵列版本

public int[] makeSequence(int begin, int end)
{
    if(end < begin)
        return null;

    int[] ret = new int[++end - begin];
    for (int i=0; begin < end; )
        ret[i++] = begin++;
    return ret;
}

这可能适合您。

void List<Integer> makeSequence(int begin, int end) {

  AtomicInteger ai=new AtomicInteger(begin);
  List<Integer> ret = new ArrayList(end-begin+1);

  while ( end-->begin) {

    ret.add(ai.getAndIncrement());

  }
  return ret;  
}