come confrontare l'array 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));
    }
}

Non so perché tutti stampano falsi.

Quando eseguo "java ByteArray", la risposta è "false false false false".

Penso che a [] sia uguale a b [] ma la JVM mi dice che mi sbaglio, perché ？？

Utilizzare Arrays.equals()se si desidera confrontare il contenuto effettivo di array che contengono valori di tipi primitivi (come byte).

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

Utilizzare Arrays.deepEqualsper il confronto di array che contengono oggetti.

Perché non sono uguali, ovvero: sono array diversi con elementi uguali all'interno.

Prova a usare Arrays.equals()o Arrays.deepEquals().

Poiché byte [] è modificabile, viene trattato come .equals()se fosse lo stesso oggetto.

Se vuoi confrontare i contenuti devi usare Arrays.equals(a, b)

BTW: Non è il modo in cui lo progetterei. ;)

hai guardato Arrays.equals()?

Modifica: se, secondo il tuo commento, il problema utilizza un array di byte come chiave HashMap, vedi questa domanda .

Se stai cercando di utilizzare l'array come chiave HashMap generica, non funzionerà. Considerare la creazione di un oggetto wrapper personalizzato che contiene l'array e il cui metodo equals(...)e hashcode(...)restituisce i risultati dai metodi java.util.Arrays. Per esempio...

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;
   }


}

Gli oggetti di questa classe wrapper funzioneranno bene come chiave per il tuo HashMap<MyByteArray, OtherType>e consentiranno un uso pulito di equals(...)e hashCode(...)metodi.

Restituiscono false perché stai testando l'identità dell'oggetto anziché l'uguaglianza del valore. Questo restituisce false perché i tuoi array sono in realtà oggetti diversi in memoria.

Se vuoi testare l'uguaglianza dei valori dovresti usare le pratiche funzioni di confronto in java.util.Arrays

per esempio

import java.util.Arrays;

'''''

Arrays.equals(a,b);

Puoi anche usare un ByteArrayComparatorda Apache Directory . Oltre a uguale a uguale , ti consente di confrontare se un array è maggiore dell'altro.

Prova per questo:

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

Inoltre non sono sicuro di questo, ma prova questo potrebbe essere che funzioni.

perché a [] non è uguale a b []? Perché la equalsfunzione è davvero chiamata Byte[]o lo byte[]è Object.equals(Object obj). Questa funzione confronta solo l'identificazione dell'oggetto, non confronta il contenuto dell'array.

Ho cercato un wrapper di array che lo rendesse paragonabile all'uso con guava TreeRangeMap. La classe non accetta il confronto.

Dopo alcune ricerche mi sono reso conto che ByteBuffer di JDK ha questa funzione e non copia l'array originale, il che è buono. Inoltre puoi confrontare più velocemente con ByteBuffer :: asLongBuffer 8 byte alla volta (inoltre non copia). Per impostazione predefinita, ByteBuffer :: wrap (byte []) utilizza BigEndian, quindi la relazione dell'ordine è la stessa del confronto dei singoli byte.

.

Confronto byte 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;
    }

Perché né ==né il equals()metodo dell'array confrontano i contenuti; entrambi valutano solo l'identità dell'oggetto (lo ==fa sempre e equals()non viene sovrascritto, quindi Objectviene utilizzata la versione da ).

Per confrontare i contenuti, utilizzare Arrays.equals().

Puoi anche utilizzare org.apache.commons.lang.ArrayUtils.isEquals ()

Arrays.equalsnon è sufficiente per un comparatore, non è possibile controllare la mappa che contiene i dati. Copio il codice da Arrays.equals, modificato per costruire un file 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;
        }
    }
}

C'è un modo più veloce per farlo:

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