¿Comparar dos matrices de primitivas en Java?

Question

Sé acerca de Arrays.deepEquals (Object [], Object []) pero esto no funciona para los tipos primitivos (debido a las limitaciones de las matrices y el autoboxing, vea this related post).

Teniendo esto en cuenta, ¿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

Cambiar la primera comparación a ser:

if (a == b) 
    return true; 

Esto no solo detecta los casos "tanto nulos", sino también "comparar una matriz a sí mismo" caso.

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

Answer 2

Creo que lo más eficiente debería ser utilizar los métodos de ayuda en la clase Arrays, ya que podrían implementarse de manera más inteligente. Así que en este caso, utilice

Arrays.equals(a, b); 

Answer 3

No sé si esto va a ayudar a nadie, pero esto 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; 
      } 
     } 

Al parecer array.equals(otherArray) hace un array == otherArray, y no lo que se esperaría .