Question

我想做的是

...
int sum[];
...
for(int z.....){
   ...
   sum[z] = some_random_value;
   ...
}

但它在行sum[z]=ran;处发出错误，表明变量sum可能尚未初始化。

我尝试int sum[] = 0;代替int sum[];，但即使这样也会出错。（我基本上是一名C程序员）

Answer 1

Java中不可能使用动态大小的数组 - 您必须在声明大小之前知道大小，或者在数组上调整操作大小（这可能很痛苦）。

相反，请使用ArrayList<Integer>，如果您需要它作为数组，则可以将其转换回来。

List<Integer> sum = new ArrayList<>();
for(int i = 0; i < upperBound; i++) {
    sum.add(i);
}
// necessary to convert back to Integer[]
Integer[] sumArray = sum.toArray(new Integer[0]);

Answer 2

这是为了摆脱编译时错误：

int sum[] = null;

但是，为了防止运行时错误，我强烈建议您像这样初始化数组：

int[] sum = new int[10];

括号中的数字表示数组大小。

如果您的尺寸是动态的，那么请使用List实施，例如ArrayList。

Answer 3

int sum[]= new int[length];

您尚未初始化。截至目前，您刚刚宣布。

并且不要认为length的{{1}}应该在初始化时决定。

即使你进行了array，你也会sum[] = null; NullPointerException结束sum[z]=ran;

我不能保持动态吗？长度是可变的

没有。在初始化时应该修复数组长度。在java中查看Collection。更具体地说，具有ArrayList实现的A List接口，即

List接口的可调整大小的数组实现。实现所有可选列表操作，并允许所有元素，包括null。

通过撰写int[] anArray = new int[10];，您正在告诉

为10个整数元素分配足够内存的数组，并将数组赋值给anArray变量。

似乎你是数组的新手，甚至是java。本教程可以帮助您更好地理解。 http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

Answer 4

在声明数组后，您仍然需要初始化：int sum[]= new int[length];。

现在，您可以将数组中的值分配到初始化时指定的大小。

如果您想要一个动态大小的数组，请使用ArrayList并在末尾调用toArray将其转换回常规数组。

Answer 5

如果您正在谈论动态数组，则该类可以表示为 -

public class DynArray {
    private int size; // The current size of the array (number of elements in the array)
    private int maxSize; // Size of memory allocated for the array
    private Object[] array; // size of array == maxSize  

    /**
     * An array constructor
     * Argument specifies how much memory is needed to allocate for elements 
     * 
     * @param sz
     * @throws IndexOutOfBoundsException
     */
    public DynArray(int sz) throws IndexOutOfBoundsException {
        // Here called another more general constructor
        this(sz, sz, null);
    }
    /**
     * Call the constructor, in which indicated how much memory is allocated 
     * for the elements and how much memory is allocated total.
     * 
     * @param sz
     * @param maxSz
     * @throws IndexOutOfBoundsException
     */
    public DynArray(int sz, int maxSz) throws IndexOutOfBoundsException {
        // Here called another more general constructor     
        this(sz, maxSz, null);
    }
    /**
     * Additional argument contains an array of elements for initialization
     * 
     * @param sz
     * @param maxSz
     * @param iniArray
     * @throws IndexOutOfBoundsException
     */
    public DynArray(int sz, int maxSz, Object[] iniArray) throws IndexOutOfBoundsException {
        if((size = sz) < 0) { 
            throw new IndexOutOfBoundsException("Negative size: " + sz);
        }

        maxSize = (maxSz < sz ? sz : maxSz);
        array = new Object[maxSize]; // memory allocation

        if(iniArray != null) { // copying items
            for(int i = 0; i < size && i < iniArray.length; i++) {
                array[i] = iniArray[i];
                // Here it was possible to use the standard method System.arraycopy
            }
        }
    }
    /**
     * Indexing
     * 
     * @param i
     * @return
     * @throws IndexOutOfBoundsException
     */
    public Object elementAt(int i) throws IndexOutOfBoundsException {
        if (i < 0 || i >= size) {
            throw new IndexOutOfBoundsException("Index" + i + 
                    " out of range [0," + (size - 1) + "]");
        }
        return array[i];
    }
    /**
     * Changing the current size of the array. argument delta specifies
     * direction of change (positive - increase the size;
     * negative -  decrease the size)
     * 
     * @param delta
     */
    public void resize(int delta) {
        if (delta > 0) enlarge(delta); // increasing the size of the array 
        else if (delta < 0) shrink(-delta); // decreasing the size of the array
    }
    /**
     * Increasing the size of the array
     * 
     * @param delta
     */
    public void enlarge(int delta) {
        if((size += delta) > maxSize) { 
            maxSize = size;
            Object[] newArray = new Object[maxSize];

            // copying elements
            for(int i =0; i < size - delta; i++)
                newArray[i] = array[i];

            array = newArray;
        }
    }
    /**
     * Decreasing the size of the array
     * 
     * @param delta
     */
    public void shrink(int delta) {
        size = (delta > size ? 0 : size - delta);
    }
    /**
     * Adding a new element
     * (with a possible increasing the size of the array)
     * 
     * @param e
     */
    public void add(Object e) {
        resize(1);
        array[size-1] = e;
    }   
    /**
     * Removing the given value - shifting elements and subsequent 
     * reduction the size of the array
     * 
     * @param e
     */
    public void remove(Object e) {
        int j;
        for(j = 0; j < size; j++) {
            if(e.equals(array[j])) {
                break;
            }
        }

        if(j == size) {
            return false;
        } else {
            for(int k = j; k < size; k++) 
                array[k] = array[k + 1]; 

            resize(-1);
            return true;
        }
    }
}

java中的动态数组

5 个答案: