Stack and Heap memory in Java

Question

As I understand , in Java, Stack memory holds primitives and method invocations and heap memory is used to store objects .

Suppose I have a class

class A {
       int a ;
       String b;
       //getters and setters
}

1. where will the primitive 'a' in class A be stored ?

2. Why does heap memory exist at all ? Why cant we store everything in stack ?

3. When the object gets garbage collected , is the stack associated with the objected destroyed ?

Answer 1

The basic difference between stack and heap is the life cycle of the values.

Stack values only exist within the scope of the function they are created in. Once it returns, they are discarded.
Heap values however exist on the heap. They are created at some point in time, and destructed at another (either by GC or manually, depending on the language/runtime).

Now Java only stores primitives on the stack. This keeps the stack small and helps keeping individual stack frames small, thus allowing more nested calls.
Objects are created on the heap, and only references (which in turn are primitives) are passed around on the stack.

So if you create an object, it is put on the heap, with all the variables that belong to it, so that it can persist after the function call returns.

Answer 2

1. In the heap, as part of the object, which is referenced by a pointer in the stack. ie. a and b will be stored adjacent to each other.
2. Because if all memory were stack memory, it wouldn't be efficient any more. It's good to have a small, fast-access area where we start and have that reference items in the much larger area of memory which remains. However, this is overkill when an object is simply a single primitive which would take up about the same amount of space on the stack as the pointer to it would.
3. Yes.

Answer 3

In case of Java, the only variables that go on stack are the local variables being used by the current method invocation. Of course only in case of primitive types their value is going to be actually stored on stack.

Answer 4

The stack is for transient data objects (like variables in your methods). The heap is for things that have to persist awhile longer.

Answer 5

1. On the heap unless Java allocates the class instance on the stack as an optimization after proving via escape analysis that this will not affect semantics. This is an implementation detail, though, so for all practical purposes except micro-optimization the answer is "on the heap".

2. Stack memory must be allocated and deallocated in last in first out order. Heap memory can be allocated and deallocated in any order.

3. When the object is garbage collected, there are no more references pointing to it from the stack. If there were, they'd keep the object alive. Stack primitives aren't garbage collected at all because they're automatically destroyed when the function returns.

Answer 6

Stack memory usually stores local variables, method calls, one over the other ..

Stack is always busy in arranging the data and popping it out after the method is executed.

stack memory stores the primitive datatype like int, double, etc.,

stack only stores the address (in other words points to the data in heap), say when you create a new object from your class A from a new program,

A X(object ) = new A;

creating 'new' object uses both stack and heap ,, whereas stack will store the address of the object in the heap (.. just an address..) the real data will be stored on the heap.

when we create another object from the class A, A Y = new A;

and when we assign, Y=X;

what will happen is, Y will just store the address of the variables used in the heap, so,

passing message to the objects X and Y makes no difference .

when you pass message to your object, x.move();

this method move(), is allocated in stack and it will just refer the heap memory with its address.. after the execution of move(), stack pops it out(that is why i said it is very active and busy)

Garbage collection is the process that java does to reclaim the memory when it is no longer used ....