I am not the JLS, but I am a Computer Scientist and this is a technical
forum.  Now estimate the chance that I mean always when I say "always"...

   robert

   Usually people who ask whether an object is "on the stack" or "on the
heap" have a C background, and think that an object being on the stack or
being on the heap is meaningful with respect to the semantics of the
program. Usually people are more interested in these semantics than whether
the object is actually on the stack or on the heap. In other words, they're
asking the wrong question. I don't know if that's the case for you, but just
in case it is, you might want to rethink what it is you're really trying to
find out about Java's behaviour.

   FWIW, some JVMs (I think IBM's JVM does this) perform analysis on the
program and make their own decisions about whether to put the object on the
stack or on the heap. The fact that the JVM is free to do either shows that
it has little effect on the actual behaviour exibited by the Java programs,
and is mainly done as a low level optimization technique.

   - Oliver

Always. In Java, all objects are dynamically allocated with "new", and
that means that they're always obtained from the heap. And as defined
in section 4.3.1 of JLS3, "An object is a class instance or an array."

So if you have:
  void someMethod() {
       int[] array;
then the reference variable "array" is on the stack and its initial
value is unknown. It is NOT necessarily null; it could be anything. The
compiler will try to keep you from accessing "array" until you have set
it either to an appropriate array reference or to null.

Now if you have:
  void someMethod() {
       int[] array = new int[10];
then the reference variable "array" is still on the stack, but now is
initialized to reference an actual array; it has a known value. The
array itself is allocated from the heap. Heap allocations are always
initialized, so all 10 int values are preset to 0.

Now suppose we have a member variable:
  public class SomeClass() {
       int[] array;
then the object containing this variable will be allocated on the heap
when it is "new"ed so the reference variable "array" is also in the
heap. Heap allocations are always initialized, so "array" starts out as
null.

How about a static member variable:
  public class SomeClass() {
       static int[] array;
then the class containing this variable will be allocated on the heap
when the class is loaded, so once again the reference variable "array"
is also in the heap. Heap allocations are always initialized, so
"array" starts out as null.