Qfyilyi

To my understanding following code should print "true"

However, when I ran this program it is printing "false" as output

According to jls-5.1.7

"If the value p being boxed is an integer literal of type int between
-128 and 127 inclusive , or the boolean literal true or false , or a character literal between 'u0000' and
'u007f' inclusive , then let a and b be the results of
any two boxing conversions of p. It is always the case that a == b."

However in case of method called via reflection boxed value is always created via new PrimitiveWrapper().

 public class Test {

    public static boolean testTrue() {

        return true;

    }



    public static void main(String args) throws Exception {

        Object trueResult = Test.class.getMethod("testTrue").invoke(null);

            System.out.println(trueResult == Boolean.TRUE);



    }

}

Please help me understand this.

invoke will always return a new Object. Any returned primitives are boxed.

...if the [return] value has a primitive type, it is first appropriately wrapped in an object.

Your issue is demonstrating the ambiguity of the term appropriately. i.e. during wrapping, it does not use Boolean.valueOf(boolean).

1.

The specific

in case of method called via reflection

is not covered by that part of the JLS you're quoting. That part you're quoting is about type conversion when you have a value of a type that you pass as another type. Here you're thinking of converting boolean to Boolean.

But type conversion means doing something like that:

Boolean b = true;

or

boolean b = true;

Boolean b2 = b;

Reflection is not a mechanism that applies type conversion.

When, by necessity, a reflective method call wraps a boolean return value into a Boolean object, it is not involved in the part of the JLS you quoted.

This explains why the JLS is not being violated here.

2.

As to why the reflection isn't choosing to be consistent with this behavior anyway:

That is because in older versions of Java, reflection existed before generics. And generics are the reason why autoboxing suddenly became convenient, and autoboxing is the reason why it seemed smart to not duplicate the "common" values of wrapped primitives.

All of this was defined after reflection already existed for a while, and was already behaving in a specific way. That means that there was already existing Java code that was using reflection, and most likely some existing code that was incorrectly relying on the existing behavior. Changing the existing behavior would have broken existing code, which was therefore avoided.