22

When searching for explanations of how logical equals == works in Java the answers are always something along the lines of:

  • For primitives it returns whether the primitives have the same value (this includes comparing a primitive to its WrapperObject as the WrapperObject gets automatically unboxed to a primitive).
  • For Objects it returns whether they represent the same Object on the Heap.

But these explanations all seem to imply that these are 2 different things, that == behaves differently depending whether you're comparing Objects vs primitives. It seems to me that they must actually be the exact same thing: Take two variables from the Stack and compare their values.

The thing that changes isn't the behavior of ==, it's what the values it's comparing represent. If the things you're comparing are primitives then the value on the Stack is the value of the primitive itself. If you're comparing Objects then the value on the Stack is the value of the reference (and thus the address of the Object on the Heap).

Have I mis-understood something, or does == actually behave the same in all situations? Bonus points if you can point me to documentation on how this really works under the covers.

Improve this question
3
  • 2
    Skip the middleman and go right to the definitive source: Java Language Reference § 15.21, Equality Operators. But I think you have the right idea: whether you're dealing with a comparison of numbers, booleans or references, they all boil down to a comparison of values. Commented Aug 18, 2019 at 2:53
  • 5
    It doesn't imply it's doing two different things from the computer's point of view--that explanation is from the human's point of view. Commented Aug 18, 2019 at 3:08
  • 1
    If you conceptually think of the object references in Java as like the pointers in C, then the content, the value, of an object reference is a number: the address of the place in memory where we can find the content of the object. So, yes, objectX == objectY is something akin to comparing two primitive integers, and in that sense == is indeed behaving the same with regard to comparing primitive values versus comparing object references. Hopefully that puts your mind at ease… but as the correct Answer by Stephen C explains, all that really matters is the behavior defined by the Java spec. Commented Aug 18, 2019 at 5:44

2 Answers 2

Reset to default
18

As other answers / comments say, at the Java language level the == operator semantics are specified (in JLS 15.21) in an implementation independent way. Strictly speaking, you cannot infer the "under the hood" implementation details from the JLS text. All that you can say is that any conformant implementation of == must behave in a certain way.

I will assume that we are talking about conventional JVMs where the actual machine representation of a reference is a machine address. It is possible to implement references in other ways; e.g using some kind of indirect addressing mechanism such as a PIDLAM.

At the bytecode level, there are a number of different bytecode instructions that implement the logic of == depending on the type (int, long or reference). However, the semantic of the comparisons are similar. Once the bytecodes have been verified as type-safe, integers and addresses can be handled the same for the purposes of == comparison at the hardware level.

At the hardware (machine instruction) level == works the same for primitive integral types and non-primitive values. In both cases it will be executing a machine instruction that compares two "words" taken from a register or from memory (heap or stack).

The JLS specified semantics of == for float and double are a bit different because the special values (infinities and not-a-number values) need special treatment. For example: NaN == NaN is false. See also the IEEE 754 floating point standard.

There are different bytecodes for this, and at the hardware level the instructions used are different to those used in the integer and reference cases. (The treatment of special values is typically handled in the floating hardware.)

The JLS specified semantics of == for boolean, byte, short and char is to promote the values to another type (int, long, float or double) before comparing them. Promotion also occurs with other cases if the operands have different (unboxed) types.

In addition, unboxing occurs if one (but not both!) of the operands is boxed. If both operands are boxed, then == is a reference comparison.

Summarizing the above ...

Have I mis-understood something, or does == actually behave the same in all situations?

No it doesn't, if you include floating point types, and the considerations of primitive widening and unboxing.

Bonus points if you can point me to documentation on how this really works under the covers.

There is no official (Oracle) public documentation for this. The JLS and JVM spec do not prescribe implementation strategies.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

4

I understand your explanation, and it is right given certain definitions of terms. But it does not fit the way Java talks of objects and primitives.

The idea of a 'reference' to an object in Java is seriously downplayed; I think it is possible to be a 'Java programmer' and not really understand what a reference is. You can memorize the rules where it makes a difference -- the '==' operator, the passing of parameters to methods -- and not understand how it is, or could be, implemented.

So I think it would be confusing to many people who program in Java to say that == 'behaves the same in all situations', because that involves too much 'under the covers' knowledge. Java doesn't encourage you (or require you) to look 'under the covers' to that extent.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.