Question: I've got a class using two generic parameters in its constructor. I would like to implement a method to compare two instances of this class, as done in the code below.

It works quite well except when one of the parameter is an arrays. I've read different topics about how to compare arrays with `java.util.Arrays.equals(Object[] a, Object[] a2)` but as my parameters are not defined as arrays, I can't use this method.

How could return "true" in the content of my array is the same? Or is it possible to cast my parameters to use `java.util.Arrays.equals(Object[] a, Object[] a2)`?

```
public class Pair<U, V> {

    public final U first;
    public final V second;

    public Pair(U first, V second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;

        Pair<?, ?> myPair= (Pair<?, ?>) o;

        if (!first.equals(myPair.first) || !second.equals(myPair.second))
            return false;
        return true;
    }
}

```

Answer: 
You can do this:

* use the guidance given [here](https://stackoverflow.com/questions/2725533/how-to-see-if-an-object-is-an-array-without-using-reflection) to determine whether both objects (this and the "other") contain arrays. Of course, detecting the actual member type means even more work.
* utilize [Array.equals()](https://stackoverflow.com/questions/8777257/equals-vs-arrays-equals-in-java) to write specific comparison code when the fields are in fact arrays.

But make no mistake: getting your `equals()` implementation to be correct, and work with inheritance and what not ... will be a major challenge! 

For example: do you consider an array of int to be equal to a list of Integer values (assuming the values are all in fact the same)? Or what about nested arrays? 

The real point here: Java doesn't have deep equality for arrays, and it is close to impossible to cover all potential cases yourself!
It's worth noting that no collection in Java that I'm aware of - pairs, lists, sets... - makes a concession for this case. As an example:

```
List<Integer[]> one = Arrays.asList(
    new Integer[]{1}, new Integer[]{2}
);
List<Integer[]> two = Arrays.asList(
    new Integer[]{1}, new Integer[]{2}
);
System.out.println(one.equals(two));

```

Output: **false**

Equality of two collections should only be determined by the equality of its elements. Anything other than that just makes the contract of your class increasingly vague.

Arrays in Java do not override equals. That's a design decision that's already been made. It's not your job to try to correct what you must perceive as the wrong decision by hacking your implementation.

So, in short, you don't.