Do two objects of a class refer to the same memory location?

Question

I am starting to learn some Java and I have been reading a lot about how memory is allocated by the JVM and consequently how this memory is freed using the garbage collector.

One thing that I have been unable to find out is if I create two new objects which are exactly the same would they refer to the same location in memory? Similar to how the String Pool works.

No. They would not. The `String` pool only applies to `String` literals; `new String("a") != new String("a")`... — Boris the Spider, Jun 28 '15 at 09:30
@BoristheSpider *"The String pool only applies to String literals"* and manually added Strings. (just to complete that sentence) :) — Tom, Jun 28 '15 at 09:57
Two objects always have distinct memory locations, by definition. — user207421, Jun 28 '15 at 10:29

Chetan Kinger · Accepted Answer · 2015-06-29T06:54:39.903

One thing that I have been unable to find out is if I create two new objects which are exactly the same would they refer to the same location in memory? Similar to how the String Pool works

The answer is No :

If you create two objects using the new keyword, they will never point to the same memory location.
This holds true for String objects as well. if you create two String objects using new, the two references to these objects will point to two different memory locations.
String literals are a special case. A String literal is stored in the String literal pool. So two String references to a String literal will always point to the same memory location.
There are other special cases in Java such as the Integer class. e.g Integer a = 100; Integer b = 100; System.out.println(a==b); This prints true because Integer values between -128 and 127 are cached by the JVM. (The values between -128 and 127 are cached by all JVM implementations. It is upto the individual JVM implementation to cache values beyond this range)

`(The range of values cached by the JVM is not specified explicitly as far as my knowledge goes)` Correct, the only thing that is specified is that the range between -128 and 127 **must** be cached, but beyond that it's up to the implementation. So much so that in Oracle VMs (and probably others too) you can change this range via the parameter `-XX:AutoBoxCacheMax` — biziclop, Jun 28 '15 at 10:29
@biziclop Thanks. Made the statement more explicit. Also, I was not aware of the `-XX:AutoBoxCacheMax` flag. Learnt something new :) — Chetan Kinger, Jun 29 '15 at 06:00

Tagir Valeev · Answer 2 · 2015-06-28T09:46:02.497

If you create the new object using the new operator, it's guaranteed to be the new object distinct from any other objects existed before. However when you create objects in indirect way (for example, using factory methods), the object existed before may be reused. A good example is Integer.valueOf(int) method which caches small numbers and returns the same instance:

Integer a = Integer.valueOf(10);
Integer b = Integer.valueOf(10);
// a and b is the same object
Integer c = new Integer(10);
Integer d = new Integer(10);
// c and d are two distinct objects

Note that even if JVM can determine that two new objects are essentially the same, it simply cannot merge them to the single object, because it would violate the language specification and may break your program later. For example, you may decide to synchronize on both of these objects later. According to the specification these synchronizations should not interfere, but if JVM merges these two objects, synchronization on the first one will have to wait for the synchronization on the second one.

In the cases where caching is used, there aren't two objects at all, only one, so the terms of the question don't apply. — user207421, Jun 28 '15 at 10:31
+1 for pointing out synchronization. The way this has been designed means that in Java no object is immutable, ever. Therefore any kind of object pooling that relies on the immutability of objects is vulnerable unless you absolutely promise not to synchronize on them. — biziclop, Jun 28 '15 at 10:35

score -1 · Answer 3 · edited May 23 '17 at 12:30

No, they are not the same object. You can verify this with the == operation which checks, whether two references refer to the same object.

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);

This will print false, which is the exact reason why you normally never want to compare Strings (or really, any object) with == (ref this post). The correct way to check for (content) equality is equals(Object that).

Do two objects of a class refer to the same memory location?

3 Answers3