¿Comparar dos matrices de primitivas en Java?

Question

Sé sobre Arrays.deepEquals (Object [], Object []) pero esto no funciona para los tipos primitivos (debido a las limitaciones de los arrays y autoboxing, consulte esta publicación relacionada ).

Con eso en mente, ¿es este el enfoque más eficiente?

boolean byteArrayEquals(byte[] a, byte[] b) {
    if (a == null && b == null)
        return true;

    if (a == null || b == null)
        return false;

    if (a.length != b.length)
        return false;

    for (int i = 0; i < a.length; i++) {
        if (a[i] != b[i])
            return false;
    }
    return true;
}

Answer 1

Cambie su primera comparación para que sea:

if (a == b)
    return true;

Esto no solo captura los "nulos" casos, pero también "comparar una matriz consigo mismo" caso.

Sin embargo, para una alternativa más simple, use Arrays.equals que tiene sobrecargas para cada tipo primitivo. (La implementación es muy similar a la suya, excepto que eleva la longitud de la matriz del bucle. En .NET eso puede ser una anti-optimización, pero supongo que los implementadores de la biblioteca JRE probablemente conozcan mejor la JVM :)

Answer 2

Creo que lo más eficiente debería ser usar los métodos auxiliares en Arrays , porque podrían implementarse de manera más inteligente. Entonces, en este caso, use

Arrays.equals(a, b);

Answer 3

No sé si esto ayudará a alguien, pero parece estar funcionando:

        if(type == type_BooleanArray) {
            boolean eq = Arrays.equals((boolean[]) thisObj, (boolean[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_ByteArray) {
            boolean eq = Arrays.equals((byte[]) thisObj, (byte[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_ShortArray) {
            boolean eq = Arrays.equals((short[]) thisObj, (short[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_CharArray) {
            boolean eq = Arrays.equals((char[]) thisObj, (char[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_IntArray) {
            boolean eq = Arrays.equals((int[]) thisObj, (int[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_LongArray) {
            boolean eq = Arrays.equals((long[]) thisObj, (long[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_FloatArray) {
            boolean eq = Arrays.equals((float[]) thisObj, (float[]) thatObj);
            if(!eq) {
                return false;
            }
        } else if(type == type_DoubleArray) {
            boolean eq = Arrays.equals((double[]) thisObj, (double[]) thatObj);
            if(!eq) {
                return false;
            }
        } else {
            if(!thisObj.equals(thatObj)) {
                return false;
            }
        }

Aparentemente array.equals (otherArray) realiza un array == otherArray , y no lo que esperaría.