बाइट सरणी (लेक्सिकोग्राफिक)

Question

के लिए जावा तुलनाकर्ता मेरे पास बाइट [] कुंजी के साथ हैशैप है। मैं इसे एक TreeMap के माध्यम से सॉर्ट करना चाहता हूं।

लेक्सिकोग्राफिक आदेश के लिए तुलनित्र को लागू करने का सबसे प्रभावी तरीका क्या है?

Answer 1

Guava का उपयोग करके आप किसी का भी उपयोग कर सकते हैं:

• UnsignedBytes.lexicographicalComparator()
• SignedBytes.lexicographicalComparator()

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

Answer 2

आप एक तुलनित्र का उपयोग कर सकते हैं जो सरणी में प्रत्येक बाइट्स के Character.toLowerCase() को मानता है (बाइट [] एएससीआईआई में है) यदि आपको चरित्र को डीकोड करने या new String(bytes, charSet).toLowerCase() का उपयोग करने की आवश्यकता नहीं है, यह कुशल होने की संभावना नहीं है।

Answer 3

मुझे लगता है कि समस्या सिर्फ "बाइट बनाम बाइट" तुलना के साथ है। सरणी से निपटना सीधा है, इसलिए मैं इसे कवर नहीं करूँगा। बाइट बनाम बाइट के संबंध में, तो मेरा पहला विचार यह करने के लिए है:

public class ByteComparator implements Comparator<byte> { 
    public int compare(byte b1, byte b2) { 
    return new Byte(b1).compareTo(b2); 
    } 
} 

लेकिन उस कोषगत नहीं होगा: 0xFF (-1 के लिए हस्ताक्षर किए बाइट) से छोटी 0x00 पर विचार किया जाएगा, जब कोषगत यह है बड़ा। मुझे लगता है कि इस चाल करना चाहिए:

public class ByteComparator implements Comparator<byte> { 
    public int compare(byte b1, byte b2) { 
    // convert to unsigned bytes (0 to 255) before comparing them. 
    int i1 = b1 < 0 ? 256 + b1 : b1; 
    int i2 = b2 < 0 ? 256 + b2 : b2; 
    return i2 - i1; 
    } 
} 

शायद वहाँ अपाचे के कॉमन्स-लैंग या यह करता है कि आम-गणित पुस्तकालयों में कुछ है, लेकिन मैं इसे बंद हाथ पता नहीं है।

Answer 4

अपाचे HBase में कोड का यह अच्छा टुकड़ा मिला:

public int compare(byte[] left, byte[] right) { 
     for (int i = 0, j = 0; i < left.length && j < right.length; i++, j++) { 
      int a = (left[i] & 0xff); 
      int b = (right[j] & 0xff); 
      if (a != b) { 
       return a - b; 
      } 
     } 
     return left.length - right.length; 
    }