Is a Java array of primitives stored in stack or heap?

I have an array declaration like this:

int a[];

Here a is an array of primitive int type. Where is this array stored? Is it stored on heap or stack? This is a primitve type int, all primitive types are not stored on heap.

As gurukulki said, it's stored on the heap. However, your post suggested a misunderstanding probably due to some well-intentioned person propagating the myth that "primitives always live on the stack". This is untrue. Local variables have their values on the stack, but not all primitive variables are local...

For example, consider this:

public class Foo
{
    int value;
}
...

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

Now, where does f.value live? The myth would suggest it's on the stack - but actually it's part of the new Foo object, and lives on the heap¹. (Note that the value of f itself is a reference, and lives on the stack.)

From there, it's an easy step to arrays. You can think of an array as just being a lot of variables - so new int[3] is a bit like having a class of this form:

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

---

¹ In fact, it's more complicated than this. The stack/heap distinction is mostly an implementation detail - I believe some JVMs, possibly experimental ones, can tell when an object never "escapes" from a method, and may allocate the whole object on the stack. However, it's conceptually on the heap, if you choose to care.

It will be stored on the heap

because array is an object in java.

EDIT : if you have

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

Think of this code as saying to the compiler, "Create an array object that will hold four ints, and assign it to the reference variable named testScores. Also, go ahead and set each int element to zero. Thanks."

It is an array of primitive types which in itself is not primitive. A good rule of thumb is when the new keyword is involved the result will be on the heap.

I just wanted to share few tests I ran on this subject.

Array of size 10 million

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

Output:

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

As you see used heap size is increased by ~80 MB, which is 10m * sizeof(double).

But if we have use Double instead of double

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

Output will show 40MB. We only have Double references, they are not initialized.

Filling it with 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();
}

Still 40MB. Because they all point to same Double object.

Initializing with double instead

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

Line

a[i] = qq.doubleValue();

is equivalent to

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

which is equivalent to

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

Since we create new Double objects each time, we blow out the heap. This shows values inside the Double class are stored in heap.

In the Java programming language arrays are objects, are dynamically created, and may be assigned to variables of type Object.

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

I guess there are two ways of looking at it, when we do something like this

    int arr[] = new int[4];
    for( int i=0;i<=3;i++ ){
        arr[i] = i*10;
    }

than I think the array is stored in heap and only the reference ariable "arr" is stored in stack. But when we do something like this int arr[] = {10,20,30,40,50}; then everything is stored in stack