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

是否有一种简单快捷的方法来生成一个

列表

，或者一个

整数[]

或

int[]

，其中包含从一些

开始

值到

结束

值的顺序值

也就是说，短于但相当于以下1：

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

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

。。。长度=10000：

对许多元素进行长时间的迭代会使事情变得更加均匀，但是eclipse和guava即使在10000个元素的测试中也保持了两倍以上的速度

因此，如果您真的想要一个

列表

，eclipse集合似乎是最好的选择——但当然，如果您以更自然的方式使用流（例如，忘记

.boxed（）

，并在基本域中进行缩减），您可能会比所有这些变体更快

---

---

1可能除了错误处理之外，例如，如果

end

begin，或者如果大小超过一些实现或JVM限制（例如，大于

2^31-1

的数组），这是我使用核心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;  
}

List makeSequence（int开始，int结束）{
List ret=新阵列列表（结束-开始+1）；
对于（inti=begin；i那么，这一行可能符合（使用）

两者都产生：

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

你可以用

您可以通过使用获取
SortedSet

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

ImmutableSortedSet=Ranges.open（1,5）.asSet（离散域.integers（））；
//集合包含[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;
}

公共列表生成序列（int开始，int结束）
{
List ret=新数组列表（++end-begin）；
对于（；开始<结束；）
ret.add（begin++）；
返回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;
}

public int[]生成序列（int开始，int结束）
{
如果（结束<开始）
返回null；
int[]ret=新int[++结束-开始]；
对于（int i=0；开始<结束；）
ret[i++]=begin++；
返回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;  
}

void List makeSequence（int-begin，int-end）{
AtomicInteger ai=新的AtomicInteger（开始）；
List ret=新阵列列表（结束-开始+1）；
while（结束-->开始）{
ret.add（ai.getAndIncrement（））；
}
返回ret；
}
Java 8非常简单，甚至不再需要单独的方法：

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

List range=IntStream.range关闭（开始、结束）
.boxed（）.collect（collector.toList（））；
以下一行Java 8版本将生成[1,2,3…10]。迭代的第一个参数是序列中的第一个nr，
限制的第一个参数是最后一个数字

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

List number=Stream.iterate（1，n->n+1）
.限额（10）
.collect（Collectors.toList（））；
您可以使用中的类

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

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

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

IntList
在界面上提供了方法
sum（）
、
min（）
、
minIfEmpty（）
、
max（）
、
maxIfEmpty（）
、
average（）
和
media（）

清晰更新：2017年11月27日

间隔
是一个
列表
，但它是惰性的和不可变的。它对于生成测试数据非常有用，特别是当您处理大量集合时。如果需要，您可以轻松地将间隔复制到
列表
，
设置
或
包
，如下所示：

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

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

区间
和
区间
没有相同的
等于
合约

更新的

您现在可以从基本流创建基本集合。根据您的偏好，有
with all
和
of all
方法。如果您好奇，我解释为什么我们有这两种方法。这些方法适用于可变和不可变的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集合的提交者
int[]arr=IntStream.rangeClosed（2,5）.toArray（）；
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);

System.out.println（Arrays.toString（arr））；
// [2, 3, 4, 5]
整数[]boxedArr=IntStream.rangeClosed（2,5）
.boxed（）.toArray（整数[]：新）；
System.out.println（Arrays.toString（boxedArr））；
//自Java 16以来
List list1=IntStream.rangeClosed（2,5）
.boxed（）.toList（）；
System.out.println（列表1）；
List list2=IntStream.rangeClosed（2,5）
.boxed（）.collect（collector.toList（））；
System.out.println（列表2）；
List list3=Arrays.asList（boxedArr）；
System.out.println（列表3）；
List list4=新的ArrayList（）；
IntStream.rangeClosed（2,5）.forEachOrdered（list4:：add）；
System.out.println（列表4）；
对于apache commons，您可以通过将该循环更改为
For（int i=begin；我不确定将
ret.add（i）
部分移动到For循环增量中是否会使其“更短”。根据该逻辑，如果我将其全部写在一行中，它会更短：）@BeeOnRope是的，肯定不是最短的，但肯定要短两行：）正如我所说，这是最接近于在核心Java中缩短它的地方。我在上面的答案中添加了ClassicCarrayList标签。使用AtomicInteger对于Resources来说非常重要，在我的测试中大约慢十倍。但是对于多线程来说它是安全的。在方法内部使用AtomicInteger没有意义。所有方法调用中的语句是由调用该方法的线程按顺序运行的，因此从AtomicInteger中除了减慢和恼人的getAndIncrement（）调用外，什么都得不到。除非您确实需要一个
列表
。
资产
生成的
连续集
是轻量级的（它只需要范围和域），但是
asList（）
将创建一个列表，该列表实际存储内存中的所有元素
public IntList makeSequence(int begin, int end) {
    return IntInterval.fromTo(begin, end);
}

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

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

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

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

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