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: 
```
@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.getClass().isArray() ^ first.getClass().isArray() || second.getClass().isArray() ^ second.getClass().isArray())
        return false;
    return deepEquals(first, myPair.first) && deepEquals(second, myPair.second);
}

private static boolean deepEquals(Object one, Object two) {
    if (one instanceof byte[])
        return Arrays.equals((byte[])one, (byte[])two);
    if (one instanceof char[])
        return Arrays.equals((char[])one, (char[])two);
    if (one instanceof short[])
        return Arrays.equals((short[])one, (short[])two);
    if (one instanceof int[])
        return Arrays.equals((int[])one, (int[])two);
    if (one instanceof long[])
        return Arrays.equals((long[])one, (long[])two);
    if (one instanceof boolean[])
        return Arrays.equals((boolean[])one, (boolean[])two);
    if (one instanceof float[])
        return Arrays.equals((float[])one, (float[])two);
    if (one instanceof double[])
        return Arrays.equals((double[])one, (double[])two);
    if (one instanceof Object[])
        return Arrays.equals((Object[])one, (Object[])two);
    return one.equals(two);
}

```
```
public class Fourth {

    public static void main(String[] args) {

        Integer a[] = {1,2,3,4,5};
        Integer b[] = {1,2,3,4,6,7};

        CompareArrays<Integer, Integer> comp = new CompareArrays<Integer, Integer>(a,b);

        comp.compareArrays();

    }
}

class CompareArrays<One extends Number, Two extends Number> {

    One[] array1;
    Two[] array2;

    CompareArrays(One[] ob1, Two[] ob2){
        array1 = ob1;
        array2 = ob2;
    }

    void compareArrays() {

        if(array1.length != array2.length) {
            System.out.println("Two arrays are not equal");

        }else {

            int flag = 0;

            for (int i = 0; i < array1.length; i++) {

                  if(array1[i] != array2[i]) {
                      flag =1;
                  }
            }

            if(flag == 0) {
                System.out.println("Two arrays are equal");
            }else {
                System.out.println("Two arrays are not equal");
            }

        }
    }
}

```