Java 创建计数数字数组的最有效方法

在每个元素都包含其下标的情况下，生成给定长度的数组的最有效方法是什么

我的虚拟级别代码的可能描述：

/**
 * The IndGen function returns an integer array with the specified dimensions.
 *  
 *  Each element of the returned integer array is set to the value of its 
 *  one-dimensional subscript.
 *  
 *  @see Modeled on IDL's INDGEN function: 
 *      http://idlastro.gsfc.nasa.gov/idl_html_help/INDGEN.html 
 *  
 *  @params size
 *  @return int[size], each element set to value of its subscript
 *  @author you
 *  
 *  */

public int[] IndGen(int size) {
    int[] result = new int[size];
    for (int i = 0; i < size; i++) result[i] = i;
    return result;
}

---

如果你不能解决这个具有挑战性的问题，无需发泄：只需转到下一个你可以处理的未回答问题。

我唯一能想到的是使用“++i”而不是“i++”，但我认为java编译器已经有了这种优化

除此之外，这几乎是最好的算法

---

您可以创建一个类，它的行为就像它有一个数组，但它没有数组一样，并且它只返回它得到的相同数字（也称为标识函数），但这不是您所要求的。

我唯一能想到的是使用“++i”而不是“i++”，但我认为java编译器已经进行了这种优化

除此之外，这几乎是最好的算法

---

您可以创建一个类，它的行为就像它有一个数组，但它没有，它只返回它得到的相同的数字（也称为标识函数），但这不是您所要求的。

正如其他人在他们的回答中所说，您的代码已经接近我所能想到的最有效的了，至少对于小型数组是如此。如果您需要多次创建这些数组，并且它们非常大，那么您可以一次性创建所有数组，然后复制它们，而不是在for循环中不断迭代。如果数组非常大，复制操作将比在数组上迭代更快。可能是这样的（在本例中，最多1000个元素）：

然后，根据您需要多次创建这些数组的代码，您可以使用如下内容：

int[] arrayOf50Elements = Arrays.copyOf(cache[49], 50);

请注意，通过这种方式，您将使用大量内存来提高速度。我想强调的是，当您需要多次创建这些阵列时，这才是值得的，这些阵列非常大，并且最大速度是您的要求之一。在我能想到的大多数情况下，你提出的解决方案将是最好的

---

编辑：我刚刚看到了您需要的大量数据和内存。我提出的方法需要n^2级的内存，其中n是您期望的最大整数。在这种情况下，这是不切实际的，因为您需要大量的内存。算了吧。我之所以离开这篇文章，是因为它可能对其他人有用。

正如其他人在回答中所说，您的代码已经接近我所能想到的最有效的了，至少对于小型阵列是如此。如果您需要多次创建这些数组，并且它们非常大，那么您可以一次性创建所有数组，然后复制它们，而不是在for循环中不断迭代。如果数组非常大，复制操作将比在数组上迭代更快。可能是这样的（在本例中，最多1000个元素）：

然后，根据您需要多次创建这些数组的代码，您可以使用如下内容：

int[] arrayOf50Elements = Arrays.copyOf(cache[49], 50);

请注意，通过这种方式，您将使用大量内存来提高速度。我想强调的是，当您需要多次创建这些阵列时，这才是值得的，这些阵列非常大，并且最大速度是您的要求之一。在我能想到的大多数情况下，你提出的解决方案将是最好的

---

编辑：我刚刚看到了您需要的大量数据和内存。我提出的方法需要n^2级的内存，其中n是您期望的最大整数。在这种情况下，这是不切实际的，因为您需要大量的内存。算了吧。我离开这篇文章是因为它可能对其他人有用。

因为一次使用TB的内存是不可行的，尤其是同时使用它们进行任何计算，你可能会考虑使用生成器。（您可能计划在阵列上循环，对吗？）使用生成器，您不需要初始化阵列（因此可以立即开始使用它），并且几乎不使用内存（O（1））

我在下面包含了一个示例实现。它受

long

原语的限制

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Counter implements Iterator<Long> {
    private long count;
    private final long max;

    public Counter(long start, long endInclusive) {
        this.count = start;
        this.max = endInclusive;
    }

    @Override
    public boolean hasNext() {
        return count <= max;
    }

    @Override
    public Long next() {
        if (this.hasNext())
            return count++;
        else
            throw new NoSuchElementException();

    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.Iterator；
导入java.util.NoSuchElementException；
公共类计数器实现迭代器{
私人长计数；
私人最终长最大值；
公共计数器（长启动、长结束）{
this.count=开始；
this.max=endInclusive；
}
@凌驾
公共布尔hasNext（）{
return count由于一次使用TB的内存是不可行的，尤其是同时使用它们进行任何计算，您可能会考虑使用生成器（您可能正计划在阵列上循环，对吧？）使用生成器，您不需要初始化阵列（因此可以立即开始使用它）并且几乎没有使用内存（O（1））

下面我提供了一个示例实现，它受到
long
原语的限制

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Counter implements Iterator<Long> {
    private long count;
    private final long max;

    public Counter(long start, long endInclusive) {
        this.count = start;
        this.max = endInclusive;
    }

    @Override
    public boolean hasNext() {
        return count <= max;
    }

    @Override
    public Long next() {
        if (this.hasNext())
            return count++;
        else
            throw new NoSuchElementException();

    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.Iterator；
导入java.util.NoSuchElementException；
公共类计数器实现迭代器{
私人长计数；
私人最终长最大值；
公共计数器（长启动、长结束）{
this.count=开始；
this.max=endInclusive；
}
@凌驾
公共布尔hasNext（）{
返回计数似乎有效。请不要进行微优化。是谁让您优化此代码的？此数组有多大？我们这里说的是兆字节还是千兆字节的数据？@sarnold，目前还不清楚。可能是10^12个元素，或者更多。要求非常高的应用程序。所以您需要3.6 TB的整数。在元素
2147483648时会发生什么
？整数是否应换回
0
，或
-2147483647
，或者您是
Iterator<Long> i = new Counter(0, 50);
while (i.hasNext()) {
    System.out.println(i.next());  // Prints 0 to 50
}