Is it true that primitive data types are always stored on the stack, and instances of reference types are stored on the heap?

Not always correct.

The storage of primitive data types and object references depends on the context:

• Local variables:

  • Primitive data types declared as local variables within methods are usually stored on the stack.
  • References to objects declared as local variables are also stored on the stack. The actual object instances are located in the heap.

• Object fields (instance variables):

  • Primitive data types that are object fields are stored in the heap as part of the object itself.
  • References to other objects that are object fields are also stored in the heap as part of the object. The referenced objects will also be in the heap.

• Static variables:

  • Static variables (both primitive and reference types) are stored as part of the class data in a memory area often called PermGen (before Java 8) or Metaspace (Java 8 and above), but this is conceptually different from the call stack for local variables.

• Escape Analysis:

  • JVM can apply an optimization called Escape Analysis. If the JVM determines that an object created in a method does not "escape" beyond that method (i.e., it is not accessible outside), then this object can be allocated directly on the stack instead of the heap (Scalar Replacement). This optimization helps avoid the overhead of garbage collection for such objects.

Thus, while local primitive variables and object references are stored on the stack, the actual object instances are always stored in the heap, and object fields are stored in the heap along with the object. Optimizations like Escape Analysis can alter this behavior in exceptional cases.