## Why is this an issue?

Comparisons of dissimilar types will always return false. The comparison and all its dependent code can simply be removed. This includes:

- comparing an object with null
- comparing an object with an unrelated primitive (E.G. a string with an int)
- comparing unrelated classes
- comparing an unrelated `class` and `interface`
- comparing unrelated `interface` types
- comparing an array to a non-array
- comparing two arrays

Specifically in the case of arrays, since arrays don’t override `Object.equals()`, calling `equals` on two arrays is the same as comparing their addresses. This means that `array1.equals(array2)` is equivalent to `array1==array2`.

However, some developers might expect `Array.equals(Object obj)` to do more than a simple memory address comparison, comparing for instance the size and content of the two arrays. Instead, the `==` operator or `Arrays.equals(array1, array2)` should always be used with arrays.

### Noncompliant code example

    interface KitchenTool { ... };
    interface Plant {...}

    public class Spatula implements KitchenTool { ... }
    public class Tree implements Plant { ...}
    //...

    Spatula spatula = new Spatula();
    KitchenTool tool = spatula;
    KitchenTool [] tools = {tool};

    Tree tree = new Tree();
    Plant plant = tree;
    Tree [] trees = {tree};

    if (spatula.equals(tree)) { // Noncompliant; unrelated classes
      // ...
    }
    else if (spatula.equals(plant)) { // Noncompliant; unrelated class and interface
      // ...
    }
    else if (tool.equals(plant)) { // Noncompliant; unrelated interfaces
      // ...
    }
    else if (tool.equals(tools)) { // Noncompliant; array & non-array
      // ...
    }
    else if (trees.equals(tools)) { // Noncompliant; incompatible arrays
      // ...
    }
    else if (tree.equals(null)) { // Noncompliant
      // ...
    }

## Resources

- CERT, EXP02-J. - Do not use the Object.equals() method to compare two arrays