java - जावा में एक हेक्स स्ट्रिंग में बाइट सरणी को कैसे परिवर्तित करें?




bytearray hex (14)

// स्थानांतरण बाइट्स अधिक कुशल // आप इसका भी उपयोग कर सकते हैं

public static String getHexString (String s) 
{
    byte[] buf = s.getBytes();

    StringBuffer sb = new StringBuffer();

    for (byte b:buf)
    {
        sb.append(String.format("%x", b));
    }


        return sb.toString();
}

मेरे पास हेक्स संख्या से भरा एक बाइट सरणी है और इसे आसान तरीका प्रिंट करना बहुत व्यर्थ है क्योंकि कई अप्रचलित तत्व हैं। मुझे जो चाहिए वह सटीक हेक्सकोड है: 3a5f771c


@maybewecouldstealavan द्वारा प्रस्तावित समाधान का एक छोटा सा संस्करण, जो आपको आउटपुट हेक्स स्ट्रिंग में एक साथ एन बाइट्स को बंडल करने देता है:

 final static char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
 final static char BUNDLE_SEP = ' ';

public static String bytesToHexString(byte[] bytes, int bundleSize /*[bytes]*/]) {
        char[] hexChars = new char[(bytes.length * 2) + (bytes.length / bundleSize)];
        for (int j = 0, k = 1; j < bytes.length; j++, k++) {
                int v = bytes[j] & 0xFF;
                int start = (j * 2) + j/bundleSize;

                hexChars[start] = HEX_ARRAY[v >>> 4];
                hexChars[start + 1] = HEX_ARRAY[v & 0x0F];

                if ((k % bundleSize) == 0) {
                        hexChars[start + 2] = BUNDLE_SEP;
                }   
        }   
        return new String(hexChars).trim();    
}

अर्थात्:

bytesToHexString("..DOOM..".toCharArray().getBytes(), 2);
2E2E 444F 4F4D 2E2E

bytesToHexString("..DOOM..".toCharArray().getBytes(), 4);
2E2E444F 4F4D2E2E

इस बारे में कैसा है?

    String byteToHex(final byte[] hash)
    {
        Formatter formatter = new Formatter();
        for (byte b : hash)
        {
            formatter.format("%02x", b);
        }
        String result = formatter.toString();
        formatter.close();
        return result;
    }

ठीक है तो ऐसा करने के तरीकों का एक गुच्छा है, लेकिन यदि आप लाइब्रेरी का उपयोग करने का निर्णय लेते हैं तो मैं आपके प्रोजेक्ट में यह देखने के लिए सुझाव दूंगा कि पुस्तकालय में कुछ ऐसा लागू किया गया है जो एक नई लाइब्रेरी जोड़ने से पहले आपके प्रोजेक्ट का हिस्सा है बस ऐसा करने के लिए। उदाहरण के लिए यदि आपके पास पहले से नहीं है

org.apache.commons.codec.binary.Hex

शायद आपके पास है ...

org.apache.xerces.impl.dv.util.HexBin


मुझे यहां तीन अलग-अलग तरीके मिले: http://www.rgagnon.com/javadetails/java-0596.html

सबसे खूबसूरत, जैसा कि वह भी नोट करता है, मुझे लगता है कि यह एक है:

static final String HEXES = "0123456789ABCDEF";
public static String getHex( byte [] raw ) {
    if ( raw == null ) {
        return null;
    }
    final StringBuilder hex = new StringBuilder( 2 * raw.length );
    for ( final byte b : raw ) {
        hex.append(HEXES.charAt((b & 0xF0) >> 4))
            .append(HEXES.charAt((b & 0x0F)));
    }
    return hex.toString();
}

मैं आम तौर पर डेबफ कथन के लिए निम्न विधि का उपयोग करता हूं, लेकिन मुझे नहीं पता कि यह करने का यह सबसे अच्छा तरीका है या नहीं

private static String digits = "0123456789abcdef";

public static String toHex(byte[] data){
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i != data.length; i++)
    {
        int v = data[i] & 0xff;
        buf.append(digits.charAt(v >> 4));
        buf.append(digits.charAt(v & 0xf));
    }
    return buf.toString();
}

मैं इसका उपयोग करना पसंद करता हूं:

final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String bytesToHex(byte[] bytes, int offset, int count) {
    char[] hexChars = new char[count * 2];
    for ( int j = 0; j < count; j++ ) {
        int v = bytes[j+offset] & 0xFF;
        hexChars[j * 2] = hexArray[v >>> 4];
        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
    }
    return new String(hexChars);
}

यह स्वीकार किए गए उत्तर का थोड़ा अधिक लचीला अनुकूलन है। निजी तौर पर, मैं इसके साथ स्वीकार्य उत्तर और इस अधिभार दोनों को रखता हूं, और अधिक संदर्भों में प्रयोग योग्य।


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

class ByteArray:

@classmethod
def char(cls, args=[]):
    cls.hexArray = "0123456789ABCDEF".encode('utf-16')
    j = 0
    length = (cls.hexArray)

    if j < length:
        v = j & 0xFF
        hexChars = [None, None]
        hexChars[j * 2] = str( cls.hexArray) + str(v)
        hexChars[j * 2 + 1] = str(cls.hexArray) + str(v) + str(0x0F)
        # Use if you want...
        #hexChars.pop()

    return str(hexChars)

array = ByteArray()
print array.char(args=[])

यहां एक java.util.Base64 -like कार्यान्वयन (आंशिक) है, क्या यह सुंदर नहीं है?

public class Base16/*a.k.a. Hex*/ {
    public static class Encoder{
        private static char[] toLowerHex={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        private static char[] toUpperHex={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        private boolean upper;
        public Encoder(boolean upper) {
            this.upper=upper;
        }
        public String encode(byte[] data){
            char[] value=new char[data.length*2];
            char[] toHex=upper?toUpperHex:toLowerHex;
            for(int i=0,j=0;i<data.length;i++){
                int octet=data[i]&0xFF;
                value[j++]=toHex[octet>>4];
                value[j++]=toHex[octet&0xF];
            }
            return new String(value);
        }
        static final Encoder LOWER=new Encoder(false);
        static final Encoder UPPER=new Encoder(true);
    }
    public static Encoder getEncoder(){
        return Encoder.LOWER;
    }
    public static Encoder getUpperEncoder(){
        return Encoder.UPPER;
    }
    //...
}

लुकअप टेबल को संग्रहीत करने की मामूली लागत पर यह कार्यान्वयन सरल और बहुत तेज़ है।

 private static final char[] BYTE2HEX=(
    "000102030405060708090A0B0C0D0E0F"+
    "101112131415161718191A1B1C1D1E1F"+
    "202122232425262728292A2B2C2D2E2F"+
    "303132333435363738393A3B3C3D3E3F"+
    "404142434445464748494A4B4C4D4E4F"+
    "505152535455565758595A5B5C5D5E5F"+
    "606162636465666768696A6B6C6D6E6F"+
    "707172737475767778797A7B7C7D7E7F"+
    "808182838485868788898A8B8C8D8E8F"+
    "909192939495969798999A9B9C9D9E9F"+
    "A0A1A2A3A4A5A6A7A8A9AAABACADAEAF"+
    "B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"+
    "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"+
    "D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"+
    "E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"+
    "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF").toCharArray();
   ; 

  public static String getHexString(byte[] bytes) {
    final int len=bytes.length;
    final char[] chars=new char[len<<1];
    int hexIndex;
    int idx=0;
    int ofs=0;
    while (ofs<len) {
      hexIndex=(bytes[ofs++] & 0xFF)<<1;
      chars[idx++]=BYTE2HEX[hexIndex++];
      chars[idx++]=BYTE2HEX[hexIndex];
    }
    return new String(chars);
  }

अपाचे कॉमन्स कोडेक लाइब्रेरी में इस प्रकार के काम करने के लिए Hex क्लास है।

import org.apache.commons.codec.binary.Hex;

String foo = "I am a string";
byte[] bytes = foo.getBytes();
System.out.println( Hex.encodeHexString( bytes ) );

DatatypeConverter.printHexBinary() प्रयोग करें। आप javax.xml.bind.DataTypeConverter में अपना दस्तावेज़ पढ़ सकते हैं

उदाहरण के लिए:

byte bytes[] = {(byte)0, (byte)0, (byte)134, (byte)0, (byte)61};
System.out.println(javax.xml.bind.DatatypeConverter.printHexBinary(bytes));

में परिणाम होगा:

000086003D

जैसा कि आप देख सकते हैं यह हेक्साडेसिमल स्ट्रिंग को प्रमुख शून्यों के साथ बाइट्स की सरणी का प्रतिनिधित्व करेगा।

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


  public static byte[] hexStringToByteArray(String s) {
    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
      data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
        + Character.digit(s.charAt(i+1), 16));
    }
  return data;
  } 

private static String bytesToHexString(byte[] bytes, int length) {
        if (bytes == null || length == 0) return null;

        StringBuilder ret = new StringBuilder(2*length);

        for (int i = 0 ; i < length ; i++) {
            int b;

            b = 0x0f & (bytes[i] >> 4);
            ret.append("0123456789abcdef".charAt(b));

            b = 0x0f & bytes[i];
            ret.append("0123456789abcdef".charAt(b));
        }

        return ret.toString();
    }







hex