Lo que estoy tratando de hacer es

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

Pero da un error en la línea sum[z]=ran; que la variable sum no podría haber sido inicializado.

Traté de int sum[] = 0; en lugar de int sum[]; pero incluso eso daba un error.
(Yo soy básicamente un programador de C)

  • bueno este problema es relativamente simple. Primero inicializar un array con algunos de longitud y rellenarla. mantenga siempre una comprobación de si la matriz está llena o no. Si esta lleno de crear una nueva instancia de array con el doble del tamaño. seguimos haciendo.
InformationsquelleAutor Daksh Shah | 2014-02-08

5 Comentarios

  1. 12

    Una matriz de tamaño dinámico no es posible en Java – usted tiene que saber el tamaño antes de declarar, o hacer cambio de tamaño de las operaciones en la matriz (que puede ser doloroso).

    En su lugar, utilice un ArrayList<Integer>, y si usted lo necesita como una matriz, se puede convertir de nuevo.

    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]); 
  2. 5

    Esto es para deshacerse de error en tiempo de compilación:

    int sum[] = null;

    Sin embargo, para evitar en tiempo de ejecución errores de yo sugiero que usted inicializar la matriz como esta:

    int[] sum = new int[10];

    El número entre paréntesis indica el tamaño de la matriz.

    Y si su tamaño es dinámica, a continuación, utilizar un List aplicación, tales como ArrayList.

  3. 3
    int sum[]= new int[length];

    Aún no se ha inicializado. A partir de ahora , sólo declaró.

    Y no para conseguir que el length de la array debe decidir en el momento de la inicialización.

    Incluso si usted no int sum[] = null; usted terminará para arriba con un NullPointerException mientras haces sum[z]=ran;

    No puedo mantenerla dinámica? la longitud es variable

    No. Matrices de longitud debe ser fijo, mientras que inicializarla. Buscar en la Colección en java. Más específicamente, Un List interfaz con ArrayList aplicación, que es

    De tamaño variable de matriz de implementación de la interfaz de Lista. Implementa todas opcional de la lista de operaciones, y permite que todos los elementos, incluidos los nulos.

    Por escrito int[] anArray = new int[10]; usted está diciendo que

    Asignar una matriz con suficiente memoria para 10 elementos de entero y asigna la matriz a la anArray variable.

    Parece que están de nuevo a la matriz e incluso para java. El tutorial puede ayudarle a comprender mejor.
    http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

    • No puedo mantenerla dinámica? la longitud es variable
    • No, En java no se puede. Eso es fijo. Usted puede desear mirar en el framework de Colecciones.
    • por qué int sum[]= new int[longitud]; y no int sum[longitud];
    • Esa es la sintaxis de cómo puede una matriz declarada 🙂 .Es bueno saber que hay muchas maneras de inicializar una matriz demasiado.
  4. 2

    Usted todavía necesita para inicializar su matriz después de que se declaró: int sum[]= new int[length];.

    Ahora puede asignar valores en la matriz hasta el tamaño especificado cuando se inicializa.

    Si quieres tener un dinámicamente el tamaño de la matriz, uso ArrayList y llame a toArray al final para volver a convertirlo en una matriz regular.

  5. 1

    Si estamos hablando de matrices dinámicas, la clase puede ser representado como –

    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;
    }
    }
    }
    • Sí, pero no ArrayList ya que hacer esto?
    • Sí, pero hay casos en los que necesitas para crear tus propias clases.
    • No estoy en desacuerdo, pero este no es uno de esos momentos. También tenga en cuenta que su copia de sus elementos en el origen de la matriz es ineficaz; referencia ArrayList del código para ver más rendimiento en el comportamiento.
    • El único momento en que puedo pensar de que sea necesario volver a aplicar un tipo [más ArrayList] es para tipos especializados, tales como int[] como una copia de seguridad, pero no se trata de hacer que (e incluso los que ya existen) .. también, por el amor de nominativo a escribir, implementar Lista.
    • Ok, gracias por los comentarios.

Dejar respuesta

Please enter your comment!
Please enter your name here