50. Taking on the hard way to discover equals()
Check out the following code:
Integer x1 = 14; Integer y1 = 14;
Integer x2 = 129; Integer y2 = 129;
List<Integer> listOfInt1 = new ArrayList<>(
Arrays.asList(x1, y1, x2, y2));
listOfInt1.removeIf(t -> t == x1 || t == x2);
List<Integer> listOfInt2 = new ArrayList<>(
Arrays.asList(x1, y1, x2, y2));
listOfInt2.removeIf(t -> t.equals(x1) || t.equals(x2));
So, initially, listOfInt1 and listOfInt2 has the same items, [x1=14, y1=14, x2=129, y2=129]. But, what will contain listOfInt1/listOfInt2 after executing the code based on removeIf() and ==, respectively equals()?The first list will remain with a single item, [129]. When t is x1, we know that x1 == x1, so 14 it is removed. But, why x2 is removed? When t is y1, we know that y1 == x1 should be false, since via == we compare the object’s references in memory, not their values. Obviously, y1 and x1 should have different references in the memory … or shouldn’t they? Actually, Java has an internal rule to cache integers in -127 … 128. Since x1=14 is cached, y1=14 uses the cache so no new Integer is created. This is why y1 == x1 and y1 is removed as well. Next, t is x2, and x2 == x2, so x2 is removed. Finally, t is y2, but y2 == x2 returns false, since 129 > 128 is not cached, so x2 and y2 have different references in memory.On the other hand, when we use equals(), which is the recommended approach for comparing the object’s values, the resulting list is empty. When t is x1, x1 = x1, so 14 it is removed. When t is y1, y1 = x1, so y1 is removed as well. Next, t is x2, and x2 = x2, so x2 is removed. Finally, t is y2, and y2 = x2, so y2 is removed as well.
51. Hooking instanceof in a nutshell
Having an object (o) and a type (t), we can use the instanceof operator to test if o is of type t by writing o instanceof t. This is a boolean operator which is very useful to ensure the success of a subsequent casting operation. For instance, check the following:
interface Furniture {};
class Plywood {};
class Wardrobe extends Plywood implements Furniture {};
The instanceof returns true if we test the object (for instance, Wardrobe) against the type itself:
Wardrobe wardrobe = new Wardrobe();
if(wardrobe instanceof Wardrobe) { } // true
Plywood plywood = new Plywood();
if(plywood instanceof Plywood) { } // true
The instanceof returns true if the tested object (for instance, Wardrobe) is an instance of a subclass of the type (for instance Plywood):
Wardrobe wardrobe = new Wardrobe();
if(wardrobe instanceof Plywood) {} // true
The instanceof returns true if the tested object (for instance, Wardrobe) implements the interface represented by the type (for instance, Furniture):
Wardrobe wardrobe = new Wardrobe();
if(wardrobe instanceof Furniture) {} // true
Based on this, we say that:
The logic behind instanceof relies upon the IS-A relationship (this is detailed in The Complete Coding Interview Guide in Java, Chapter 6, What is inheritance?). In a nutshell, this relationship is based on interface implementation or class inheritance. For instance, wardrobe instanceof Plywood returns true because Wardrobe extends Plywood, so Wardrobe IS A Plywood. Similarly, Wardrobe IS A Furniture. On the other hand, Plywood IS-not-A Furniture, so plywood instanceof Furniture returns false. In this context, since every Java class extends Object, we know that foo instanceof Object returns true as long as foo is an instance of a Java class. In addition, null instanceof Object (or any other object) returns false, so this operator doesn’t require an explicit null check.
Finally, keep in mind that instanceof works only with reified types (a reified type information is available at runtime) which includes:
Primitive types (int, float)
Raw types (List, Set)
Non-generic classes/interfaces (String)
Generic types with unbounded wildcards (List <?>, Map<?, ?>)
Arrays of reifiable types (String[], Map<?, ?>[], Set<?>[])
This means that we cannot use the instanceof operator (or casts) with parameterized types because the type erasures alter all type parameters in generic code, so we cannot say which parameterized type for a generic type is in use at runtime.