मैप कुंजी

Question

के रूप में बाइट सरणी का उपयोग करना क्या आपको मानचित्र कुंजी के रूप में बाइट सरणी का उपयोग करने में कोई समस्या दिखाई देती है? मैं new String(byte[]) और हैश String द्वारा भी कर सकता हूं लेकिन यह byte[] का उपयोग करने के लिए अधिक सरल है।

Answer 1

समस्या यह है कि byte[] का उपयोग करता है equals और hashCode के लिए पहचान आपत्ति है, इसलिए कि

byte[] b1 = {1, 2, 3} 
byte[] b2 = {1, 2, 3} 

HashMap में मेल नहीं खाएगा। मैं तीन विकल्प देखें: एक String में

1. रैपिंग, लेकिन फिर आप मुद्दों एन्कोडिंग के बारे में सावधान रहना होगा (-> स्ट्रिंग -> बाइट आप एक ही बाइट्स देता है आप कुछ करने के लिए है कि बाइट की जरूरत है)।
2. List<Byte> का उपयोग करें (स्मृति में महंगा हो सकता है)।
3. बाइट सरणी की सामग्री का उपयोग करने के लिए hashCode और equals लिखकर अपनी खुद की रैपिंग कक्षा करें।

Answer 2

मेरा मानना ​​है कि जावा में सरणी hashCode() और equals(Object) विधियों को सहजता से कार्यान्वित नहीं करती हैं। यही है, दो समान बाइट एरे जरूरी नहीं है कि वे एक ही हैश कोड साझा करें और वे जरूरी नहीं होने का दावा करेंगे। इन दो लक्षणों के बिना, आपका हैश मैप अप्रत्याशित रूप से व्यवहार करेगा।

इसलिए, मैं के विरुद्ध byte[] का उपयोग हैश मैप में कुंजी के रूप में करता हूं।

Answer 3

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

आप मान लिया जाये कि वास्तव में समानता चाहते हैं;

false 
1671711 
11394033 

(। तथ्य यह है कि वे अलग हैं महत्वपूर्ण है वास्तविक संख्या अप्रासंगिक हैं):

byte[] array1 = new byte[1]; 
byte[] array2 = new byte[1]; 

System.out.println(array1.equals(array2)); 
System.out.println(array1.hashCode()); 
System.out.println(array2.hashCode()); 

प्रिंट कुछ की तरह: उदाहरण के लिए , मेरा सुझाव है कि आप अपना खुद का रैपर बनाएं जिसमें byte[] शामिल है और समानता और हैश कोड पीढ़ी को उचित रूप से लागू करता है:

public final class ByteArrayWrapper 
{ 
    private final byte[] data; 

    public ByteArrayWrapper(byte[] data) 
    { 
     if (data == null) 
     { 
      throw new NullPointerException(); 
     } 
     this.data = data; 
    } 

    @Override 
    public boolean equals(Object other) 
    { 
     if (!(other instanceof ByteArrayWrapper)) 
     { 
      return false; 
     } 
     return Arrays.equals(data, ((ByteArrayWrapper)other).data); 
    } 

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

ध्यान दें कि आप में ByteArrayWrapper उपयोग करने के बाद बाइट सरणी के भीतर मान बदलते हैं, एक प्रमुख के रूप में अगर एक HashMap (आदि) आप समस्याओं फिर से कुंजी को देख होगा ... आप की एक प्रति ले सकता है यदि आप चाहते हैं तो ByteArrayWrapper कन्स्ट्रक्टर में डेटा, लेकिन स्पष्ट रूप से यह प्रदर्शन की बर्बादी होगी यदि आपको पता है कि बाइट सरणी की सामग्री को बदल नहीं रहा है।

संपादित करें: टिप्पणियों में उल्लिखित अनुसार, आप इसके लिए ByteBuffer का उपयोग भी कर सकते हैं (विशेष रूप से, इसकी ByteBuffer#wrap(byte[]) विधि)। मुझे नहीं पता कि यह वास्तव में सही बात है, ByteBuffer की सभी अतिरिक्त क्षमताओं को देखते हुए आपको इसकी आवश्यकता नहीं है, लेकिन यह एक विकल्प है।

Answer 4

मैं समस्याओं को देखने के बाद आप Arrays.equals और Array.hashCode का उपयोग करना चाहिए, डिफ़ॉल्ट सरणी कार्यान्वयन के स्थान पर

Answer 5

Arrays.toString (बाइट)

Answer 6

आप java.math.BigInteger इस्तेमाल कर सकते हैं। इसमें BigInteger(byte[] val) कन्स्ट्रक्टर है। यह एक संदर्भ प्रकार है, इसलिए हैशटेबल के लिए एक कुंजी के रूप में इस्तेमाल किया जा सकता है। और .equals() और .hashCode() को संबंधित पूर्णांक संख्याओं के रूप में परिभाषित किया गया है, जिसका अर्थ है कि बिगइंटर के पास बाइट [] सरणी के रूप में समरूपता के बराबर बराबर है।

Answer 7

हम इस के लिए उपयोग कर सकते हैं ByteBuffer

HashMap<ByteBuffer, byte[]> kvs = new HashMap<ByteBuffer, byte[]>(); 
byte[] k1 = new byte[]{1,2 ,3}; 
byte[] k2 = new byte[]{1,2 ,3}; 
byte[] val = new byte[]{12,23,43,4}; 

kvs.put(ByteBuffer.wrap(k1), val); 
System.out.println(kvs.containsKey(ByteBuffer.wrap(k2))); 

प्रिंट होगा

true 

Answer 8

तुम भी करने के लिए बाइट [] परिवर्तित कर सकते हैं (यह मूल रूप से एक तुलनित्र के साथ बाइट [] आवरण है) एक ' बेस 32 या बेस 64 का उपयोग करके सुरक्षित 'स्ट्रिंग, उदाहरण के लिए:

byte[] keyValue = new byte[] {…}; 
String key = javax.xml.bind.DatatypeConverter.printBase64Binary(keyValue); 

बेशक उपर्युक्त, ली के कई रूप हैं ke:

String key = org.apache.commons.codec.binary.Base64.encodeBase64(keyValue); 

Answer 9

आप ByteArrKey और अधिभार hashCode और बराबर तरीकों की तरह एक वर्ग somthing बनाने का उपयोग करना चाहिए उन दोनों के बीच अनुबंध याद है।

इससे आपको अधिक लचीलापन मिलेगा क्योंकि आप बाइट सरणी के अंत में संलग्न 0 प्रविष्टियों को छोड़ सकते हैं, विशेष रूप से यदि आप केवल कुछ भाग को अन्य बाइट बफर बनाते हैं।

इस तरह आप तय करेंगे कि दोनों वस्तुएं बराबर कैसे होनी चाहिए।

Answer 10

मुझे आश्चर्य है कि उत्तर सबसे सरल विकल्प को इंगित नहीं कर रहे हैं।

हां, हैश मैप का उपयोग करना संभव नहीं है, लेकिन कोई भी आपको वैकल्पिक रूप से सॉर्टेड मैप का उपयोग करने से रोकता है। एकमात्र चीज एक तुलनात्मक लिखना है जिसे सरणी की तुलना करने की आवश्यकता है। यह एक HashMap के रूप में के रूप में performant नहीं है, लेकिन अगर आप एक सरल विकल्प चाहते हैं, ये रहा है (यदि आप कार्यान्वयन छुपाना चाहते हैं आप मानचित्र के साथ SortedMap जगह ले सकता है):

private SortedMap<int[], String> testMap = new TreeMap<>(new ArrayComparator()); 

private class ArrayComparator implements Comparator<int[]> { 
    @Override 
    public int compare(int[] o1, int[] o2) { 
     int result = 0; 
     int maxLength = Math.max(o1.length, o2.length); 
     for (int index = 0; index < maxLength; index++) { 
     int o1Value = index < o1.length ? o1[index] : 0; 
     int o2Value = index < o2.length ? o2[index] : 0; 
     int cmp  = Integer.compare(o1Value, o2Value); 
     if (cmp != 0) { 
      result = cmp; 
      break; 
     } 
     } 
     return result; 
    } 
    } 

इस कार्यान्वयन दूसरे के लिए समायोजित किया जा सकता सरणी, केवल एक चीज जिसे आपको अवगत होना चाहिए वह यह है कि बराबर सरणी (बराबर सदस्यों के बराबर लंबाई) 0 को वापस करनी चाहिए और आपके पास एक दृढ़ संकल्प

Answer 11

यहां ट्रीमैप, तुलनात्मक इंटरफ़ेस और जावा विधि जावा का उपयोग करने का एक समाधान है। use.Arays.equals (बाइट [], बाइट []);

नोट: मानचित्र में आदेश देने के लिए इस विधि का

SortedMap<byte[], String> testMap = new TreeMap<>(new ArrayComparator()); 

static class ArrayComparator implements Comparator<byte[]> { 
    @Override 
    public int compare(byte[] byteArray1, byte[] byteArray2) { 

     int result = 0; 

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

     if (!areEquals) { 
      result = -1; 
     } 

     return result; 
    } 
}