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

Question

有以产生一个短和甜方式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 和第三方库，我想我会测试所有解决方案的性能。

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

• classicArrayList ：上面在我的问题中给出的代码（基本上与 adarshr 的答案相同）。
• eclipseCollections ：下面使用 Eclipse Collections 8.0 在Donald 的回答中给出的代码。
• guavaRange ：下面daveb 的回答中给出的代码。 从技术上讲，这不会创建List<Integer>而是创建ContiguousSet<Integer> - 但由于它按顺序实现Iterable<Integer> ，它主要适用于我的目的。
• intStreamRange ：下面Vladimir 的回答中给出的代码，它使用IntStream.rangeClosed() - 它是在 Java 8 中引入的。
• streamIterate ：下面Catalin 的回答中给出的代码也使用了 Java 8 中引入的IntStream功能。

以下是每秒千次操作的结果（数字越大越好），对于上述所有大小为 10 的列表：

...再次对于大小为 10,000 的列表：

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

当然，这里发生的事情是 guava 和 eclipse 解决方案实际上并没有实现任何类型的 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 个元素的测试中，eclipse 和 guava 的速度仍然是两倍多。

所以如果你真的想要一个List<Integer> ，eclipse 集合似乎是最好的选择 - 但当然，如果你以更原生的方式使用流（例如，忘记.boxed()并减少原始域）你'最终可能会比所有这些变体都快。

---

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

Answer 1

使用 Java 8，它非常简单，因此它甚至不再需要单独的方法：

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

Answer 2

嗯，这个班轮可能符合条件（使用番石榴范围）

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

这不会创建List<Integer> ，但ContiguousSet提供了许多相同的功能，特别是实现Iterable<Integer> ，它允许以与List<Integer>相同的方式实现foreach 。

在旧版本中（在 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]

Answer 3

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

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

Answer 4

您可以使用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);
}

如果你想避免拳击整数为整数，但仍像一个表结构的结果，那么你可以使用IntList与IntInterval从Eclipse的集合。

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

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

更新为清晰：11/27/2017

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

IntInterval是一个ImmutableIntList ，它扩展了IntList 。 它还具有转换器方法。

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

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

Eclipse Collections 9.0更新

您现在可以从原始流创建原始集合。 根据您的喜好，有withAll和ofAll方法。 如果你很好奇，我会解释为什么我们这里都有。 这些方法适用于可变和不可变的 Int/Long/Double Lists、Sets、Bags 和 Stacks。

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 的提交者

Answer 5

这是我使用 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;  
}

Answer 6

你可以使用番石榴范围

您可以通过使用获得SortedSet

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

Answer 7

int[] arr = IntStream.rangeClosed(2, 5).toArray();
System.out.println(Arrays.toString(arr));
// [2, 3, 4, 5]

Integer[] boxedArr = IntStream.rangeClosed(2, 5)
  .boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(boxedArr));

// Since Java 16
List<Integer> list1 = IntStream.rangeClosed(2, 5)
  .boxed().toList();
System.out.println(list1);

List<Integer> list2 = IntStream.rangeClosed(2, 5)
  .boxed().collect(Collectors.toList());
System.out.println(list2);

List<Integer> list3 = Arrays.asList(boxedArr);
System.out.println(list3);

List<Integer> list4 = new ArrayList<>();
IntStream.rangeClosed(2, 5).forEachOrdered(list4::add);
System.out.println(list4);

Answer 8

这是我能找到的最短的。

列表版本

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;
}

Answer 9

这个可能对你有用......

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;  
}