¿Cómo comparar la matriz Java Byte []?

public class ByteArr {

    public static void main(String[] args){
        Byte[] a = {(byte)0x03, (byte)0x00, (byte)0x00, (byte)0x00};
        Byte[] b = {(byte)0x03, (byte)0x00, (byte)0x00, (byte)0x00};
        byte[] aa = {(byte)0x03, (byte)0x00, (byte)0x00, (byte)0x00};
        byte[] bb = {(byte)0x03, (byte)0x00, (byte)0x00, (byte)0x00};

        System.out.println(a);
        System.out.println(b);
        System.out.println(a == b);
        System.out.println(a.equals(b));

        System.out.println(aa);
        System.out.println(bb);
        System.out.println(aa == bb);
        System.out.println(aa.equals(bb));
    }
}

No sé por qué todos imprimen falso.

Cuando ejecuto "java ByteArray", la respuesta es "falso falso falso falso".

Creo que a [] es igual a b [] pero la JVM me dice que estoy equivocado, ¿por qué?

Úselo Arrays.equals()si desea comparar el contenido real de matrices que contienen valores de tipos primitivos (como byte).

System.out.println(Arrays.equals(aa, bb));

Se utiliza Arrays.deepEqualspara comparar matrices que contienen objetos.

Porque no son iguales, es decir, son matrices diferentes con elementos iguales en su interior.

Intente usar Arrays.equals()o Arrays.deepEquals().

Como el byte [] es mutable, se trata como .equals()si fuera el mismo objeto.

Si quieres comparar los contenidos tienes que utilizar Arrays.equals(a, b)

Por cierto: no es la forma en que lo diseñaría. ;)

has mirado Arrays.equals()?

Editar: si, según su comentario, el problema es usar una matriz de bytes como clave HashMap, consulte esta pregunta .

Si está tratando de usar la matriz como una clave HashMap genérica, eso no funcionará. Considere la posibilidad de crear un objeto contenedor personalizado que contenga la matriz y cuyo método equals(...)y hashcode(...)devuelva los resultados de los métodos java.util.Arrays. Por ejemplo...

import java.util.Arrays;

public class MyByteArray {
   private byte[] data;

   // ... constructors, getters methods, setter methods, etc...


   @Override
   public int hashCode() {
      return Arrays.hashCode(data);
   }

   @Override
   public boolean equals(Object obj) {
      if (this == obj)
         return true;
      if (obj == null)
         return false;
      if (getClass() != obj.getClass())
         return false;
      MyByteArray other = (MyByteArray) obj;
      if (!Arrays.equals(data, other.data))
         return false;
      return true;
   }


}

Los objetos de esta clase contenedora funcionarán bien como clave para usted HashMap<MyByteArray, OtherType>y permitirán un uso limpio de los métodos equals(...)y hashCode(...).

Devuelven falso porque está probando la identidad del objeto en lugar de la igualdad de valores. Esto devuelve falso porque sus matrices son en realidad diferentes objetos en la memoria.

Si desea probar la igualdad de valores, debe usar las prácticas funciones de comparación en java.util.Arrays

p.ej

import java.util.Arrays;

'''''

Arrays.equals(a,b);

También puede utilizar un archivoByteArrayComparator de Apache Directory . Además de igual, le permite comparar si una matriz es mayor que la otra.

Intente esto:

boolean blnResult = Arrays.equals(byteArray1, byteArray2);

Tampoco estoy seguro de esto, pero intente que esto funcione.

¿Por qué a [] no es igual a b []? Porque la equalsfunción realmente se llama Byte[]o byte[]está Object.equals(Object obj). Esta función solo compara la identificación del objeto, no compara el contenido de la matriz.

Busqué un contenedor de matriz que lo haga comparable al uso con guava TreeRangeMap. La clase no acepta comparador.

Después de investigar un poco, me di cuenta de que ByteBuffer de JDK tiene esta función y no copia la matriz original, lo cual es bueno. Además, puede comparar más rápido con ByteBuffer :: asLongBuffer 8 bytes a la vez (tampoco copia). Por defecto, ByteBuffer :: wrap (byte []) usa BigEndian para que la relación de orden sea la misma que comparar bytes individuales.

.

Comparación de bytes de Java,

public static boolean equals(byte[] a, byte[] a2) {
        if (a == a2)
            return true;
        if (a == null || a2 == null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i = 0; i < length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

Porque ==ni el equals()método de la matriz compara los contenidos; ambos solo evalúan la identidad del objeto ( ==siempre lo hace y equals()no se sobrescribe, por lo que Objectse usa la versión de ).

Para comparar los contenidos, utilice Arrays.equals().

También puede utilizar org.apache.commons.lang.ArrayUtils.isEquals ()

Arrays.equalsno es suficiente para un comparador, no se puede comprobar que el mapa contiene los datos. Copio el código de Arrays.equals, modificado para compilar un Comparator.

class ByteArrays{
    public static <T> SortedMap<byte[], T> newByteArrayMap() {
        return new TreeMap<>(new ByteArrayComparator());
    }

    public static SortedSet<byte[]> newByteArraySet() {
        return new TreeSet<>(new ByteArrayComparator());
    }

    static class ByteArrayComparator implements Comparator<byte[]> {
        @Override
        public int compare(byte[] a, byte[] b) {
            if (a == b) {
                return 0;
            }
            if (a == null || b == null) {
                throw new NullPointerException();
            }

            int length = a.length;
            int cmp;
            if ((cmp = Integer.compare(length, b.length)) != 0) {
                return cmp;
            }

            for (int i = 0; i < length; i++) {
                if ((cmp = Byte.compare(a[i], b[i])) != 0) {
                    return cmp;
                }
            }

            return 0;
        }
    }
}

Hay una forma más rápida de hacerlo:

Arrays.hashCode(arr1) == Arrays.hashCode(arr2)