Re: Strings...immutable?
jupiter wrote:
Heap and stack are two different memory storage spaces. One is
for Object and one is for references to Object.
It helped me to "see" in my mind that a String is put on the heap
as an Object, while references remain only on the stack pointing to
the Object address.
So, s starts out being a reference and remains a reference. When
it points to "hello" it points to the "hello" Object on the heap.
When s points to "hellogoodbye" it's pointing to a new heap Object.
So they are different objects, and nothing has been mutated.
I think that's right. Is that right? I think somebody will
correct me if not.
The memory management in the JVM is much more complicated than that (I
don't know much about, so anyone correct me if I get something wrong).
There is the basic stack frame (per thread?), which stores all of the
local variables, Object references, etc. Then there is the heap space,
which stores the actual objects. There is also a separate space for the
class references and internal String references -- String's interns are
NOT stored in the heap.
So, the "hello" object has a pointer on the stack frame, a reference to
the String variable in the heap, a reference to the class AND the
interned String in the other memory space.
As two asides:
1. a java.lang.OutOfMemoryError: heap space cannot be due to having too
many String interns, it can only be due to using too much data.
2. This should return true, using the Sun JVM:
public class Foo {
final static String bar1 = "Hello";
final static String bar2 = "Hello";
public static boolean equal() {
return bar1 == bar2;
}
}