Posts Tagged ‘object’
hashCode() implementations should rely only on an internal object state. Making them dependent on other objects, context of use and other external conditions conflicts with the general contracts of consistency:
“For any reference values
y, multiple invocations of
trueor consistently return
“Whenever it is invoked on the same object more than once during an execution of a Java application, the
hashCodemethod must consistently return the same integer” [*]
Violating those contracts may cause all kinds of weird and unpredictable behavior.
A known example of this antipattern is
java.net.URL implementation where they are depending on information returned by a domain name server, rather than on actual stored URL data.
toString() method gives you a cheap way to provide human-readable labels for objects in output. When the objects are used in GUI containers, such as
JTables, it allows to use the default models and renderers instead of writing the custom ones.
Creating new instances of immutable primitive type wrappers (such as
Number subclasses and
Booleans) wastes the memory and time needed for allocating new objects. Static
valueOf() method works much faster than a constructor and saves the memory, as it caches frequently used instances.
It is guaranteed that two
Boolean instances and
Integers between -128 and 127 to be pre-cached, thus you definitely should not use the constructor to instantiate them.
If you override
equals() method in your class, always check if an argument is null. If a null value is passed,
equals() must unconditionally return
NullPointerException should be thrown!).
If a class implements
compareTo() method must return zero if and only if
true for the same non-null argument (and vice versa). Violating this rule may cause unexpected behavior of the objects.
If you override
equals() in your class, always provide a custom implementation of
hashCode() that returns the same hash code value for two or more equal objects:
a.hashCode() == b.hashCode()
This is, in fact, a general contract defined by Java API Specification. Violation of this rule (which is likely the case if
equals() method is overridden while
hashCode() is inherited from
Object) may cause numerous bugs and unexpected behaviours.
Note that the reverse rule: two or more unequal objects must have different hash codes, or
a.hashCode() != b.hashCode()
though not required, is also highly recommended to be maintained wherever possible (except for the cases when a number of class instances is known to be greater than
Integer.MAX_VALUE). Disregard of this rule (hash collisions) may reduce performance of HashMaps and Hashtables.