¿Se almacena una matriz Java de primitivas en pila o montón?

Tengo una declaración de matriz como esta:

int a[];

Aquí ahay una matriz de inttipo primitivo . ¿Dónde se almacena esta matriz? ¿Se almacena en un montón o en una pila? Este es un tipo intprimitivo, todos los tipos primitivos no se almacenan en el montón.

Como dijo gurukulki, se almacena en el montón. Sin embargo, su publicación sugirió un malentendido probablemente debido a que alguna persona bien intencionada propagó el mito de que "los primitivos siempre viven en la pila". Esto es falso. Las variables locales tienen sus valores en la pila, pero no todas las variables primitivas son locales ...

Por ejemplo, considere esto:

public class Foo
{
    int value;
}
...

public void someOtherMethod()
{
    Foo f = new Foo();
    ...
}

Ahora bien, ¿dónde f.valuevive? El mito sugeriría que está en la pila, pero en realidad es parte del nuevo Fooobjeto y vive en el montón ¹ . (Tenga en cuenta que el valor de fsí mismo es una referencia y vive en la pila).

A partir de ahí, es un paso fácil para las matrices. Puede pensar en una matriz como si fueran muchas variables, por lo que new int[3]es un poco como tener una clase de esta forma:

public class ArrayInt3
{
    public readonly int length = 3;
    public int value0;
    public int value1;
    public int value2;
}

¹ De hecho, es más complicado que esto. La distinción pila / montón es principalmente un detalle de implementación; creo que algunas JVM, posiblemente experimentales, pueden decir cuándo un objeto nunca "escapa" de un método y pueden asignar todo el objeto a la pila. Sin embargo, está conceptualmente en el montón, si decide preocuparse.

Se almacenará en el montón

porque array es un objeto en java.

EDITAR : si tienes

int [] testScores; 
testScores = new int[4];

Piense en este código como si le dijera al compilador: "Cree un objeto de matriz que tenga cuatro entradas y asígnelo a la variable de referencia nombrada testScores. Además, siga adelante y establezca cada intelemento en cero. Gracias".

Es una serie de tipos primitivos que en sí mismos no son primitivos. Una buena regla general es que cuando la nueva palabra clave está involucrada, el resultado estará en el montón.

Solo quería compartir algunas pruebas que hice sobre este tema.

Matriz de tamaño 10 millones

public static void main(String[] args) {
    memInfo();
    double a[] = new double[10000000];
    memInfo();
}

Salida:

------------------------
max mem = 130.0 MB
total mem = 85.0 MB
free mem = 83.6 MB
used mem = 1.4 MB
------------------------
------------------------
max mem = 130.0 MB
total mem = 130.0 MB
free mem = 48.9 MB
used mem = 81.1 MB
------------------------

Como puede ver, el tamaño del montón usado aumenta en ~ 80 MB, que es 10 m * tamaño de (doble).

Pero si usamos Double en lugar de double

public static void main(String[] args) {
    memInfo();
    Double a[] = new Double[10000000];
    memInfo();
}

La salida mostrará 40 MB. Solo tenemos referencias dobles, no están inicializadas.

Llenarlo con Double

public static void main(String[] args) {
    memInfo();
    Double a[] = new Double[10000000];      
    Double qq = 3.1d;
    for (int i = 0; i < a.length; i++) {
        a[i] = qq;
    }
    memInfo();
}

Todavía 40 MB. Porque todos apuntan al mismo objeto Double.

Inicializando con doble en su lugar

public static void main(String[] args) {
    memInfo();
    Double a[] = new Double[10000000];
    Double qq = 3.1d;
    for (int i = 0; i < a.length; i++) {
        a[i] = qq.doubleValue();
    }
    memInfo();
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Línea

a[i] = qq.doubleValue();

es equivalente a

a[i] = Double.valueOf(qq.doubleValue());

que es equivalente a

a[i] = new Double(qq.doubleValue());

Como creamos nuevos objetos Double cada vez, explotamos el montón. Esto muestra que los valores dentro de la clase Double se almacenan en el montón.

En el lenguaje de programación Java, las matrices son objetos, se crean dinámicamente y pueden asignarse a variables de tipo Object.

http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html