जावा बाइट [] सरणी की तुलना कैसे करें?

Question

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

मुझे नहीं पता कि वे सभी झूठ क्यों छापते हैं।

जब मैं "जावा बाइटएयर्रे" चलाता हूं, तो उत्तर "गलत झूठी झूठी" है।

मुझे लगता है कि एक [] बी के बराबर है] लेकिन जेवीएम मुझे बता रहा है कि मैं गलत हूं, क्यों]

Comments

दो बाइट एरेज़

— वडज़िम

Answer 1

का प्रयोग करें Arrays.equals()अगर आप सरणियों कि आदिम प्रकार मूल्यों (बाइट) समाहित होते हैं की वास्तविक सामग्री की तुलना करना चाहते।

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

Arrays.deepEqualsऑब्जेक्ट्स में सरणियों की तुलना के लिए उपयोग करें ।

Comments

अगर मेरे पास 'HashMap <बाइट [], IoBuffer>' और i 'put (a, बफर)' है, तो, अगर मैं 'print (map.containsKey (b)' 'it "" false "प्रिंट करता हूं, तो क्या यह वही है कारण????

— आलसी

@ आलसी: हाँ, कारण वही है ... आप नक्शे में चाबी के रूप में कच्ची बाइट [] का उपयोग नहीं कर सकते हैं ... यहाँ पढ़ें: stackoverflow.com/questions/1058149/…

— लुकाज़

Answer 2

क्योंकि वे समान नहीं हैं, अर्थात: वे अंदर समान तत्वों के साथ विभिन्न सरणियाँ हैं।

का उपयोग करके देखें Arrays.equals()या Arrays.deepEquals()।

Comments

यह जावा बकवास का हिस्सा है: किसी अन्य कक्षा में वस्तुओं की तुलना करने के लिए एक अलग वर्ग से एक स्थिर विधि का उपयोग क्यों करें? यह है: उन्होंने equals()विधि को ओवरराइड क्यों नहीं किया ?

— यू। विंडल

Answer 3

जैसा कि बाइट [] उत्परिवर्तनीय है इसे केवल .equals()उसी वस्तु के रूप में माना जा रहा है ।

यदि आप उन सामग्रियों की तुलना करना चाहते हैं जिनका आपको उपयोग करना है Arrays.equals(a, b)

BTW: इसका तरीका यह नहीं है कि मैं इसे डिज़ाइन करूँगा। ;)

Answer 4

क्या तुमने देखा Arrays.equals()?

संपादित करें: यदि, आपकी टिप्पणी के अनुसार, मुद्दा एक बाइट सरणी का उपयोग हाशप की कुंजी के रूप में कर रहा है तो इस प्रश्न को देखें ।

Comments

अगर मेरे पास 'HashMap <बाइट [], IoBuffer>' और i 'put (a, बफर)' है, तो, अगर मैं 'print (map.containsKey (b)' 'it "" false "प्रिंट करता हूं, तो क्या यह वही है कारण????

— आलसी

@ आलसी - देखें stackoverflow.com/questions/1058149/…

— Dan Vinton

Answer 5

यदि आप सरणी को एक सामान्य HashMap कुंजी के रूप में उपयोग करने की कोशिश कर रहे हैं, तो यह काम नहीं करेगा। एक कस्टम आवरण उद्देश्य यह है कि सरणी, और जिसका रखती बनाने पर विचार करें equals(...)और hashcode(...)विधि java.util.Arrays तरीकों से परिणाम देता है। उदाहरण के लिए...

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


}

इस रैपर क्लास की वस्तुएं आपके लिए एक कुंजी के रूप में ठीक काम HashMap<MyByteArray, OtherType>करेंगी और इनका उपयोग करने के तरीकों equals(...)और hashCode(...)तरीकों को साफ करने की अनुमति देंगी ।

Answer 6

वे झूठे लौट रहे हैं क्योंकि आप मूल्य समानता के बजाय वस्तु पहचान के लिए परीक्षण कर रहे हैं। यह गलत है क्योंकि आपके सरणियाँ वास्तव में स्मृति में अलग-अलग वस्तुएं हैं।

यदि आप मान समानता के लिए परीक्षण करना चाहते हैं तो java.util.Arrays में आसान तुलना कार्यों का उपयोग करना चाहिए

जैसे

import java.util.Arrays;

'''''

Arrays.equals(a,b);

Answer 7

आप अपाचे निर्देशिकाByteArrayComparator से भी उपयोग कर सकते हैं । बराबरी के अलावा यह आपको तुलना करने देता है कि क्या एक सरणी दूसरे से अधिक है।

Answer 8

इसके लिए प्रयास करें:

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

मैं इस बारे में निश्चित नहीं हूं, लेकिन कोशिश करें कि यह काम करे।

Answer 9

क्यों [] बी के बराबर नहीं है []? क्योंकि equalsफ़ंक्शन वास्तव में कहा जाता है Byte[]या byte[]है Object.equals(Object obj)। यह कार्य केवल ऑब्जेक्ट आइडेंटिटी की तुलना करता है, एरे की सामग्री की तुलना नहीं करता है।

Answer 10

मैंने एक एरे रैपर की तलाश की, जो अमरुद ट्रीरैंगपाइप के साथ उपयोग करने के लिए तुलनीय हो। वर्ग तुलनित्र स्वीकार नहीं करता है।

कुछ शोध के बाद मुझे महसूस हुआ कि JDK के बाइटबफ़र में यह सुविधा है और यह मूल सरणी की नकल नहीं करता है जो अच्छा है। अधिक से अधिक आप तेजी से बाइटबफ़र के साथ तुलना कर सकते हैं :: asLongBuffer 8 बाइट्स समय पर (कॉपी नहीं करता है)। डिफ़ॉल्ट रूप से बाइटबफ़र :: रैप (बाइट []) बिगइंडियन का उपयोग करते हैं इसलिए ऑर्डर रिलेशन व्यक्तिगत बाइट्स की तुलना करने के समान है।

।

Answer 11

जावा बाइट तुलना,

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

Answer 12

क्योंकि न तो ==और न ही equals()सरणी की विधि सामग्री की तुलना करती है; दोनों केवल वस्तु पहचान का मूल्यांकन करते हैं ( ==हमेशा करता है, और equals()अधिलेखित नहीं Objectकिया जाता है , इसलिए से संस्करण का उपयोग किया जा रहा है)।

सामग्री की तुलना के लिए, का उपयोग करें Arrays.equals()।

Answer 13

आप org.apache.commons.lang.ArrayUtils.isEquals () का भी उपयोग कर सकते हैं

Answer 14

Arrays.equalsएक तुलनित्र के लिए पर्याप्त नहीं है, आप नक्शे की जांच कर सकते हैं जिसमें डेटा शामिल नहीं है। मैं Arrays.equalsएक से निर्माण करने के लिए संशोधित कोड से कॉपी करता हूं 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;
        }
    }
}

Answer 15

ऐसा करने का एक तेज़ तरीका है:

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

Comments

"तेज़" से आपका मतलब "धीमा" है।

— डिविजेक