CODEWITHSUNDEEP
javaarraysheap-memoryprimitive-typesstack-memory
user241924
user241924

Reputation: 4438

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.

Upvotes: 104

Views: 54965

Answers (7)

acheron55
acheron55

Reputation: 5619

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[10_000_000];
    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[10_000_000];
    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[10_000_000];        
    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[10_000_000];
    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.

Upvotes: 24

Esben Skov Pedersen
Esben Skov Pedersen

Reputation: 4517

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.

Upvotes: 29

GuruKulki
GuruKulki

Reputation: 26428

It will be stored on the heap, because array is an object in Java.

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

Upvotes: 45

POUDEL BANWO
POUDEL BANWO

Reputation: 1

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

Upvotes: -1

Man Off Sky
Man Off Sky

Reputation: 13

In the example int arr[] = {10,20,30,40,50};, both the array itself and its values will be stored in the heap, while the reference variable arr will be stored in the stack.

Upvotes: 1

Jon Skeet
Jon Skeet

Reputation: 1503469

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 heap1. (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;
}

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

Upvotes: 170

Nikola Gedelovski
Nikola Gedelovski

Reputation: 1000

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

Upvotes: 3

Related Questions