Est-ce qu'un tableau Java de primitives est stocké dans stack ou heap?

comme gurukulki a dit, il est stocké sur le tas. Cependant, votre billet suggère un malentendu probablement dû à une personne bien intentionnée propageant le mythe que "les primitifs vivent toujours sur la pile". Ce qui est inexact. variables locales ont leurs valeurs sur la pile, mais toutes les variables primitives ne sont pas locales...

par exemple, considérez ceci:

public class Foo
{
    int value;
}
...

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

maintenant, où vit f.value ? Le mythe serait suggérez qu'il est sur la pile - mais en fait, il fait partie de la nouvelle Foo objet, et vit sur le tas ¹ . (Notez que la valeur de f lui-même est une référence, et vit sur la pile.)

de là, c'est une étape facile pour les tableaux. Vous pouvez penser à un tableau comme étant juste un grand nombre de variables - donc new int[3] est un peu comme avoir une classe de cette forme:

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

---

¹ En fait, c'est plus compliqué que cela. La distinction stack/heap est principalement un détail d'implémentation - je crois que certaines JVM, éventuellement expérimentales, peuvent dire quand un objet ne "s'échappe" jamais d'une méthode, et peuvent affecter l'objet entier sur la pile. Cependant, c'est conceptuellement sur le tas, si vous choisissez de vous en soucier.

il sera stocké sur le tas

parce que array est un objet en java.

EDIT : si vous avez

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

pense à ce code comme disant au compilateur, "crée un objet array qui contiendra quatre ints, et l'assignera à la variable de référence nommée testScores . Aussi, Allez-y et réglez chaque élément int à zéro. Grâce."

C'est un tableau de types primitifs qui, en soi, n'est pas primitif. Une bonne règle empirique est que lorsque le nouveau mot-clé est impliqué le résultat sera sur le tas.

je voulais juste partager quelques tests que j'ai fait sur ce sujet.

Tableau de taille 10 millions de

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

sortie:

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

comme vous voyez la taille de tas utilisée est augmentée d'environ 80 MB, qui est de 10m * sizeof(double).

mais si nous avons utiliser Double au lieu de double

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

La sortie

affichera 40MB. Nous n'avons que des références doubles, elles ne sont pas initialisées.

le remplir de 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();
}

Encore 40 MO. Parce qu'ils pointent tous vers le même Double objet.

Initialisation avec double au lieu de

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

ligne

a[i] = qq.doubleValue();

est équivalent à

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

qui est l'équivalent de

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

depuis que nous créons de nouveaux objets doubles à chaque fois, nous souffrons le tas. Ce montre que les valeurs à l'intérieur de la classe Double sont stockées dans heap.

dans le langage de programmation Java, les tableaux sont des objets, sont créés dynamiquement et peuvent être assignés à des variables de type Objet.

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