Java Array Deep Equal deepEquals(Object[] a1, Object[] a2)

Description

deep Equals

License

Apache License

Declaration

public static boolean deepEquals(Object[] a1, Object[] a2) 

Method Source Code

//package com.java2s;
/*/*from  w w w. j a v  a  2  s.  c om*/
 * Copyright 2010 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

public class Main {
    /**
     * @since 1.5
     */
    public static boolean deepEquals(Object[] a1, Object[] a2) {
        if (a1 == a2)
            return true;
        if (a1 == null || a2 == null)
            return false;
        int len = a1.length;
        if (len != a2.length)
            return false;
        for (int i = 0; i < len; i++) {
            Object e1 = a1[i];
            Object e2 = a2[i];
            if (e1 == e2)
                continue;
            if (e1 == null)
                return false;
            boolean eq = (e1.getClass() != e2.getClass() || !e1.getClass().isArray() || !e2.getClass().isArray())
                    ? e1.equals(e2)
                    : (e1 instanceof Object[] && e2 instanceof Object[]) ? deepEquals((Object[]) e1, (Object[]) e2)
                            : (e1 instanceof byte[] && e2 instanceof byte[]) ? equals((byte[]) e1, (byte[]) e2)
                                    : (e1 instanceof short[] && e2 instanceof short[])
                                            ? equals((short[]) e1, (short[]) e2)
                                            : (e1 instanceof int[] && e2 instanceof int[])
                                                    ? equals((int[]) e1, (int[]) e2)
                                                    : (e1 instanceof long[] && e2 instanceof long[])
                                                            ? equals((long[]) e1, (long[]) e2)
                                                            : (e1 instanceof char[] && e2 instanceof char[])
                                                                    ? equals((char[]) e1, (char[]) e2)
                                                                    : (e1 instanceof boolean[]
                                                                            && e2 instanceof boolean[])
                                                                                    ? equals((boolean[]) e1,
                                                                                            (boolean[]) e2)
                                                                                    : (e1 instanceof float[]
                                                                                            && e2 instanceof float[])
                                                                                                    ? equals(
                                                                                                            (float[]) e1,
                                                                                                            (float[]) e2)
                                                                                                    : (e1 instanceof double[]
                                                                                                            && e2 instanceof double[])
                                                                                                                    ? equals(
                                                                                                                            (double[]) e1,
                                                                                                                            (double[]) e2)
                                                                                                                    : e1.equals(
                                                                                                                            e2);

            if (!eq)
                return false;
        }
        return true;
    }

    public static boolean equals(long[] a, long[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(int[] a, int[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(short[] a, short a2[]) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(char[] a, char[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(byte[] a, byte[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(boolean[] a, boolean[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(double[] a, double[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(float[] a, float[] a2) {
        return java.util.Arrays.equals(a, a2);
    }

    public static boolean equals(Object[] a, Object[] a2) {
        return java.util.Arrays.equals(a, a2);
    }
}

Related

1. deepEquals(boolean[] array1, boolean[] array2)
2. deepEquals(Object[] a1, Object[] a2)
3. deepEquals(Object[] a1, Object[] a2)