Are Java method references stable? [duplicate]

Question

If I obtain a method reference using the new syntax:

anObject::aMethod 

Do I always get the same object? That is, can I trust that two references to the same method will be equal?

This is good to know if, for example, I plan to use them as Runnable callbacks that I can add and remove:

someLibrary.addCallback(anObject::aMethod) // later someLibrary.removeCallback(sameObject::sameMethod) 

Would this require saving the reference in a Runnable variable to keep it stable?

Answer 1

JLS makes no promises about identity or equality of what you get out of method reference expressions.

You can run a quick test:

Object obj = new Object();  IntSupplier foo = obj::hashCode; IntSupplier bar = obj::hashCode;  System.out.println(foo == bar);  // false  System.out.println(foo.equals(bar));  // false       

But this is, of course, implementation dependent.

You could make your lambda Serializable and key your callback map with the serlialized representation. See How to serialize a lambda?. While this will work, it's not exactly required to work by the specs.

Answer 2

Just try this out to get the answer:

Object object = ...; Supplier<String> s1 = object::toString; Supplier<String> s2 = object::toString; System.out.println(s1.equals(s2)); 

And the answer is... unfortunately not.

OF course if you keep the same reference (i.e. the same object), it will work; but if, as the example above, you request two lambdas, although they seem to be identical, they will never be equal. Therefore reference = object::methodand then later remove(reference) will obviously work, but remove(sameObject::sameMethod) from a collection will never work if it is written literaly as such.

The answer is also no for constructor (e.g. ArrayList::new) and unbound methods (e.g. Object::toString). It seems that a new lambda is constructed each time you use a lambda expression.

As @Hitobat points it out, this unequality makes sense if you think about what exactly are lambdas and where do they come from. Basicly, Supplier<String> x = myObject::toString is a syntactic suggar for Supplier<String> x = new Supplier<String>( ... ). Without a proper Object.equals overloading, two instances of an anonymous class are obviously different. As many people probably, I though that there was a kind of cache of frequently used lambdas somewhere to make it more efficient; well, not at all.