How does Object.toString() get the "memory address" and how can I mimic it

Question

The toString method of Object is unique in that it seems to be the only place in Java where the memory address is viewable. How does Object do this?

I would like to know so that I can mimic its implementation in a class of my own. I can't use super.toString() because I'm extending a class which overrides toString already.

Update: The premise of my question asks for the memory address, but the answers have indicated that this premise is incorrect, so what I am actually asking is: How does Object.toString() return what it does, and how can I mimic it?

Take a look at the API doc. It’s not the memory address. And there is a way to get the same without using `toString()`. — Ole V.V., Apr 02 '16 at 17:13
See http://stackoverflow.com/questions/909843/how-to-get-the-unique-id-of-an-object-which-overrides-hashcode — Ole V.V., Apr 02 '16 at 17:17
@mmirwaldt, no. `Object.toString()` uses the actual hash code implementation, not `System.identityHashCode`, and `System.identityHashCode` has nothing to do with the memory address. — Louis Wasserman, Apr 02 '16 at 17:33
See http://stackoverflow.com/questions/13860194/what-is-an-internal-address-in-java — Raedwald, Apr 04 '16 at 06:28

score 15 · Accepted Answer · edited Jun 20 '20 at 09:12

15

It is not the memory address, it is the hashCode(). See also Object.toString() which says (in part)

The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character @, and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
getClass().getName() + '@' + Integer.toHexString(hashCode())

And Object.hashCode() says (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java™ programming language.) so it's not required to be a memory address, and if used it's only visible to the internal (native) implementation of Object.

edited Jun 20 '20 at 09:12

Community

1
1

answered Apr 02 '16 at 17:15

Elliott Frisch

198,278
20
158
249

This answer is the most helpful of the answers, so I am selecting it even though other answers have also been very helpful (such as the fact that I can use `System.identityHashCode`) – 4castle Apr 02 '16 at 17:56
Java is terrible, this is another example of that. The '@' sign is read as 'at', thus if you see `object@f024`, you intuitively think that the object is located **at** that memory address. Using the '@' symbol was a terrible design decision. – Jabba Oct 18 '20 at 15:01
@Jabba What would your proposed alternative default `Object.toString()` use and where would you document it? – Elliott Frisch Oct 18 '20 at 15:06

Peter Lawrey · Answer 2 · 2016-04-02T18:17:29.803

The toString method of Object is unique in that it seems to be the only place in Java where the memory address is viewable. How does Object do this?

It doesn't get the address, in the HotSpot JVM, it gets a randomly generated 31-bit hashcode stored in the header of the object. This has to be stored because;

the hashcode cannot change even if the object is moved and has a new address.
the address is not random enough. The lower 8-bits of the address are always 0. After every GC, the first object to be creates is always the same.
the address could be 64-bit.

DO TRY THIS AT HOME, NOT SUITABLE FOR WORK!!.

You can get/set the hashCode() using Unsafe

static final Unsafe UNSAFE;

static {
    try {
        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        UNSAFE = (Unsafe) theUnsafe.get(null);
    } catch (Exception e) {
        throw new AssertionError(e);
    }
}

public static void setIdentityHashCode(Object o, int code) {
    UNSAFE.putInt(o, 1l, code & 0x7FFF_FFF);
}

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    Double d = 1.0;
    Double d2 = 1.0;
    setIdentityHashCode(d, 1);
    setIdentityHashCode(d2, 1);
    System.out.println("d: "+d+" System.identityHashCode(d): "+System.identityHashCode(d));
    System.out.println("d2: "+d2+" System.identityHashCode(d2): "+System.identityHashCode(d2));
    System.out.println("d == d2: " + (d == d2));
}

prints

d: 1.0 System.identityHashCode(d): 1
d2: 1.0 System.identityHashCode(d2): 1
d == d2: false

You can get the address from the reference value provided you know how the memory has been translated. In the simplest case, (where you have 64-bit references) the reference is untranslated and the address is the value stored in the reference.

If you run this on a 64-bit JVM with -XX:-UseCompressedOops

// This only works if a GC doesn't move the object while attempting to access it.
static final Unsafe UNSAFE;

static {
    try {
        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        UNSAFE = (Unsafe) theUnsafe.get(null);
    } catch (Exception e) {
        throw new AssertionError(e);
    }
}

// run with: -ea -XX:-UseCompressedOops
public static void main(String[] args) {
    Object i = 0x12345678;
    System.out.printf("indentityHashCode = %08x%n", System.identityHashCode(i));

    Object[] obj = { i };
    assert Unsafe.ARRAY_OBJECT_INDEX_SCALE == 8; // 8 bytes per reference.
    long address = UNSAFE.getLong(obj, (long) Unsafe.ARRAY_OBJECT_BASE_OFFSET);
    System.out.printf("%x%n", address);
    for (int j=0;j<24;j++)
        System.out.printf("%02x ", UNSAFE.getByte(address + j) & 0xFF);
    System.out.println();
    // now some really scary sh!t
    UNSAFE.putLong(i, 8L, UNSAFE.getLong(0L, 8L));
    System.out.printf("`i` is now a %s and is %x%n", i.getClass(), i);
}

prints

indentityHashCode = 5a07e868
7fbf41cb8560
01 68 e8 07 5a 00 00 00 48 33 3f b9 b9 7f 00 00 78 56 34 12 00 00 00 00 
   ^^hashCode^          ^class address  ^       ^int value^
`i` is now a class java.lang.Long and is 12345678

Don't tell this to people, they'll actually try it :D – noctarius Apr 02 '16 at 18:15 — noctarius, Apr 02 '16 at 18:15
@noctarius added an NSFW warning. – Peter Lawrey Apr 02 '16 at 18:17 — Peter Lawrey, Apr 02 '16 at 18:17

Louis Wasserman · Answer 3 · 2016-04-02T17:43:02.317

9

It doesn't. What it gets is the hash code, not the memory address, and the hash code has no necessary connection to the memory address. (It might in some implementations.)

In the base implementation, that's System.identityHashCode, though it still has no relationship to the memory address.

edited Apr 02 '16 at 17:43

answered Apr 02 '16 at 17:13

Louis Wasserman

191,574
25
345
413

1

hashCode is a random number in HotSpot (by default) – ZhekaKozlov Apr 02 '16 at 17:19
So how could I mimic the implementation of `Object.toString()`? – 4castle Apr 02 '16 at 17:32
2

@4castle the entire implementation is `getClass().getName() + '@' + Integer.toHexString(hashCode())`. That's the whole implementation. But that has nothing to do with the memory address. – Louis Wasserman Apr 02 '16 at 17:33
@Louis Okay, so how do I mimic/get the `hashCode()` if, hypothetically, it had been overwritten by the super class? – 4castle Apr 02 '16 at 17:36
2

@4castle that's `System.identityHashCode(object)`, but still, that has nothing to do with the memory address. – Louis Wasserman Apr 02 '16 at 17:37

score 0 · Answer 4 · answered Apr 02 '16 at 17:26

If you may find the definition of this toString() in Object Class. You will find this.

getClass().getName() + '@' + Integer.toHexString(hashCode()) //returns classname@hashCode.

What it gets is the hash-code , not the memory address (As per Louis Wasserman) , and the hash code has no necessary connection to the memory address.

you should override this toString() for each class that you declared in your Project as per your Need.

score 0 · Answer 5 · answered Aug 04 '16 at 16:03

0

This is not a loophole to get a hold of a memory address because all you get is a randomly generated 31 bit hash-code in the header of the object. It doesn't provide any real way get a hold of a real memory address.

answered Aug 04 '16 at 16:03

sixtytrees

1,156
1
10
25

How does Object.toString() get the "memory address" and how can I mimic it

5 Answers5

Linked