How to Compare Long in Java

The Long class in Java provides a method called equals() for comparing Long objects. Understanding how to correctly compare Long objects is crucial for avoiding unexpected behavior in your Java programs. This article explains how to use the equals() method effectively and highlights common pitfalls to avoid.

Using the equals() Method for Long Comparison

The equals() method in the Long class compares the object it’s called upon with the object passed as an argument. It returns true if the following conditions are met:

• The argument is not null.
• The argument is an instance of the Long class.
• The argument represents the same long value as the object the method is called on.

Otherwise, the equals() method returns false.

Here’s an example demonstrating the usage of equals():

Long long1 = new Long(123L);
Long long2 = new Long(123L);
Long long3 = new Long(456L);

System.out.println(long1.equals(long2)); // Output: true
System.out.println(long1.equals(long3)); // Output: false
System.out.println(long1.equals("123")); // Output: false (different object type)
System.out.println(long1.equals(null)); // Output: false (null argument)

Comparing with == Operator: Potential Pitfalls

While the == operator can be used to compare Long objects, it’s crucial to understand its behavior to avoid potential issues.

The == operator compares object references, not the actual values. For Long objects within the range of -128 to 127, Java maintains a pool of cached objects. When you use autoboxing (e.g., Long long1 = 123L;), objects within this range are retrieved from the pool. Consequently, comparing them with == yields true. However, for values outside this range, new Long objects are created, leading to different object references.

Long long4 = 123L; // Autoboxing, within cached range
Long long5 = 123L; // Retrieves the same object from the pool
Long long6 = 128L; // Autoboxing, outside cached range
Long long7 = 128L; // Creates a new Long object

System.out.println(long4 == long5); // Output: true (same object reference)
System.out.println(long6 == long7); // Output: false (different object references)

Therefore, relying solely on == for Long comparison can lead to inconsistent results. It’s strongly recommended to use the equals() method for reliable value comparisons, ensuring accuracy regardless of the object’s origin or cached status.

Conclusion

When comparing Long objects in Java, prioritize the equals() method for accurate value comparisons. Avoid using the == operator unless you explicitly intend to compare object references, as it can lead to unexpected behavior due to object caching. Using equals() consistently guarantees correct comparisons and avoids potential bugs in your code. Always strive for clarity and reliability in your comparisons to build robust and maintainable Java applications.