Konversi representasi string dari dump hex ke array byte menggunakan Java?

Saya mencari cara untuk mengkonversi string panjang (dari dump), yang mewakili nilai hex menjadi array byte.

Saya tidak bisa mengutarakannya lebih baik daripada orang yang memposting pertanyaan yang sama di sini .

Tetapi untuk tetap asli, saya akan mengucapkannya dengan cara saya sendiri: seandainya saya memiliki string "00A0BF"yang ingin saya tafsirkan sebagai

byte[] {0x00,0xA0,0xBf}

apa yang harus saya lakukan?

Saya seorang pemula Java dan akhirnya menggunakan BigIntegerdan mengawasi untuk memimpin nol nol. Tapi saya pikir itu jelek dan saya yakin saya kehilangan sesuatu yang sederhana.

Inilah solusi yang menurut saya lebih baik daripada yang diposting sejauh ini:

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

Alasan mengapa ini merupakan peningkatan:

• Aman dengan nol di depan (tidak seperti BigInteger) dan dengan nilai byte negatif (tidak seperti Byte.parseByte)

• Tidak mengubah String menjadi char[], atau membuat objek StringBuilder dan String untuk setiap byte tunggal.

• Tidak ada dependensi perpustakaan yang mungkin tidak tersedia

Jangan ragu untuk menambahkan pemeriksaan argumen melalui assertatau pengecualian jika argumen tersebut tidak diketahui aman.

Satu baris:

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

Peringatan :

• di Java 9 Jigsaw ini bukan lagi bagian dari set root java.se (default) sehingga akan menghasilkan ClassNotFoundException kecuali Anda menentukan --add-modules java.se.ee (terima kasih kepada @ eckes)
• Tidak tersedia di Android (terima kasih Fabianatas perhatiannya), tetapi Anda dapat mengambil kode sumber jika sistem Anda kekurangan javax.xmlkarena beberapa alasan. Terima kasih kepada @ Bert Regelinkuntuk mengekstraksi sumbernya.

Kelas Hex di commons-codec harus melakukan itu untuk Anda.

http://commons.apache.org/codec/

import org.apache.commons.codec.binary.Hex;
...
byte[] decoded = Hex.decodeHex("00A0BF");
// 0x00 0xA0 0xBF

Anda sekarang dapat menggunakan BaseEncoding di guavauntuk mencapai hal ini.

BaseEncoding.base16().decode(string);

Untuk membalikkannya gunakan

BaseEncoding.base16().encode(bytes);

Sebenarnya, saya pikir solusi BigInteger sangat bagus:

new BigInteger("00A0BF", 16).toByteArray();

Sunting: Tidak aman untuk memimpin nol , seperti yang dicatat oleh poster.

Satu baris:

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

Bagi Anda yang tertarik pada kode aktual di belakang One-liners dari FractalizeR (saya membutuhkannya karena javax.xml.bind tidak tersedia untuk Android (secara default)), ini berasal dari com.sun.xml.internal.bind. DatatypeConverterImpl.java :

public byte[] parseHexBinary(String s) {
    final int len = s.length();

    // "111" is not a valid hex encoding.
    if( len%2 != 0 )
        throw new IllegalArgumentException("hexBinary needs to be even-length: "+s);

    byte[] out = new byte[len/2];

    for( int i=0; i<len; i+=2 ) {
        int h = hexToBin(s.charAt(i  ));
        int l = hexToBin(s.charAt(i+1));
        if( h==-1 || l==-1 )
            throw new IllegalArgumentException("contains illegal character for hexBinary: "+s);

        out[i/2] = (byte)(h*16+l);
    }

    return out;
}

private static int hexToBin( char ch ) {
    if( '0'<=ch && ch<='9' )    return ch-'0';
    if( 'A'<=ch && ch<='F' )    return ch-'A'+10;
    if( 'a'<=ch && ch<='f' )    return ch-'a'+10;
    return -1;
}

private static final char[] hexCode = "0123456789ABCDEF".toCharArray();

public String printHexBinary(byte[] data) {
    StringBuilder r = new StringBuilder(data.length*2);
    for ( byte b : data) {
        r.append(hexCode[(b >> 4) & 0xF]);
        r.append(hexCode[(b & 0xF)]);
    }
    return r.toString();
}

Ini HexBinaryAdaptermemberikan kemampuan untuk marshal dan unmarshal antara Stringdan byte[].

import javax.xml.bind.annotation.adapters.HexBinaryAdapter;

public byte[] hexToBytes(String hexString) {
     HexBinaryAdapter adapter = new HexBinaryAdapter();
     byte[] bytes = adapter.unmarshal(hexString);
     return bytes;
}

Itu hanya contoh yang saya ketikkan ... Saya sebenarnya hanya menggunakannya apa adanya dan tidak perlu membuat metode terpisah untuk menggunakannya.

Berikut adalah metode yang benar-benar berfungsi (berdasarkan beberapa jawaban semi-benar sebelumnya):

private static byte[] fromHexString(final String encoded) {
    if ((encoded.length() % 2) != 0)
        throw new IllegalArgumentException("Input string must contain an even number of characters");

    final byte result[] = new byte[encoded.length()/2];
    final char enc[] = encoded.toCharArray();
    for (int i = 0; i < enc.length; i += 2) {
        StringBuilder curr = new StringBuilder(2);
        curr.append(enc[i]).append(enc[i + 1]);
        result[i/2] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

Satu-satunya masalah yang mungkin saya lihat adalah jika string input sangat panjang; memanggil toCharArray () membuat salinan array internal string.

EDIT: Oh, dan omong-omong, byte ditandatangani di Java, jadi string input Anda dikonversi ke [0, -96, -65] alih-alih [0, 160, 191]. Tapi Anda mungkin sudah tahu itu.

Di android, jika Anda bekerja dengan hex, Anda dapat mencoba okio .

penggunaan sederhana:

byte[] bytes = ByteString.decodeHex("c000060000").toByteArray();

dan hasilnya akan

[-64, 0, 6, 0, 0]

The BigInteger()Metode dari java.math sangat lambat dan tidak recommandable.

Integer.parseInt(HEXString, 16)

dapat menyebabkan masalah dengan beberapa karakter tanpa mengonversi ke Digit / Integer

Metode yang Bekerja dengan Baik:

Integer.decode("0xXX") .byteValue()

Fungsi:

public static byte[] HexStringToByteArray(String s) {
    byte data[] = new byte[s.length()/2];
    for(int i=0;i < s.length();i+=2) {
        data[i/2] = (Integer.decode("0x"+s.charAt(i)+s.charAt(i+1))).byteValue();
    }
    return data;
}

Bersenang-senang, Semoga Sukses

EDIT: seperti yang ditunjukkan oleh @mmyers, metode ini tidak bekerja pada input yang berisi substring yang sesuai dengan byte dengan set bit tinggi ("80" - "FF"). Penjelasannya ada di Bug ID: 6259307 Byte.parseByte tidak berfungsi seperti yang diiklankan di Dokumentasi SDK .

public static final byte[] fromHexString(final String s) {
    byte[] arr = new byte[s.length()/2];
    for ( int start = 0; start < s.length(); start += 2 )
    {
        String thisByte = s.substring(start, start+2);
        arr[start/2] = Byte.parseByte(thisByte, 16);
    }
    return arr;
}

Untuk apa nilainya, inilah versi lain yang mendukung string panjang ganjil, tanpa menggunakan penggabungan string.

public static byte[] hexStringToByteArray(String input) {
    int len = input.length();

    if (len == 0) {
        return new byte[] {};
    }

    byte[] data;
    int startIdx;
    if (len % 2 != 0) {
        data = new byte[(len / 2) + 1];
        data[0] = (byte) Character.digit(input.charAt(0), 16);
        startIdx = 1;
    } else {
        data = new byte[len / 2];
        startIdx = 0;
    }

    for (int i = startIdx; i < len; i += 2) {
        data[(i + 1) / 2] = (byte) ((Character.digit(input.charAt(i), 16) << 4)
                + Character.digit(input.charAt(i+1), 16));
    }
    return data;
}

Saya selalu menggunakan metode seperti

public static final byte[] fromHexString(final String s) {
    String[] v = s.split(" ");
    byte[] arr = new byte[v.length];
    int i = 0;
    for(String val: v) {
        arr[i++] =  Integer.decode("0x" + val).byteValue();

    }
    return arr;
}

metode ini membagi nilai hex yang dibatasi ruang tetapi tidak akan sulit untuk membuatnya membagi string pada kriteria lain seperti ke dalam pengelompokan dua karakter.

Saya suka solusi Character.digit, tapi inilah cara saya menyelesaikannya

public byte[] hex2ByteArray( String hexString ) {
    String hexVal = "0123456789ABCDEF";
    byte[] out = new byte[hexString.length() / 2];

    int n = hexString.length();

    for( int i = 0; i < n; i += 2 ) {
        //make a bit representation in an int of the hex value 
        int hn = hexVal.indexOf( hexString.charAt( i ) );
        int ln = hexVal.indexOf( hexString.charAt( i + 1 ) );

        //now just shift the high order nibble and add them together
        out[i/2] = (byte)( ( hn << 4 ) | ln );
    }

    return out;
}

Kode yang disajikan oleh Bert Regelink tidak berfungsi. Coba yang berikut ini:

import javax.xml.bind.DatatypeConverter;
import java.io.*;

public class Test
{  
    @Test
    public void testObjectStreams( ) throws IOException, ClassNotFoundException
    {     
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);

            String stringTest = "TEST";
            oos.writeObject( stringTest );

            oos.close();
            baos.close();

            byte[] bytes = baos.toByteArray();
            String hexString = DatatypeConverter.printHexBinary( bytes);
            byte[] reconvertedBytes = DatatypeConverter.parseHexBinary(hexString);

            assertArrayEquals( bytes, reconvertedBytes );

            ByteArrayInputStream bais = new ByteArrayInputStream(reconvertedBytes);
            ObjectInputStream ois = new ObjectInputStream(bais);

            String readString = (String) ois.readObject();

            assertEquals( stringTest, readString);
        }
    }

Saya menemukan Kernel Panic memiliki solusi yang paling berguna bagi saya, tetapi mengalami masalah jika string hex adalah angka ganjil. dipecahkan dengan cara ini:

boolean isOdd(int value)
{
    return (value & 0x01) !=0;
}

private int hexToByte(byte[] out, int value)
{
    String hexVal = "0123456789ABCDEF"; 
    String hexValL = "0123456789abcdef";
    String st = Integer.toHexString(value);
    int len = st.length();
    if (isOdd(len))
        {
        len+=1; // need length to be an even number.
        st = ("0" + st);  // make it an even number of chars
        }
    out[0]=(byte)(len/2);
    for (int i =0;i<len;i+=2)
    {
        int hh = hexVal.indexOf(st.charAt(i));
            if (hh == -1)  hh = hexValL.indexOf(st.charAt(i));
        int lh = hexVal.indexOf(st.charAt(i+1));
            if (lh == -1)  lh = hexValL.indexOf(st.charAt(i+1));
        out[(i/2)+1] = (byte)((hh << 4)|lh);
    }
    return (len/2)+1;
}

Saya menambahkan sejumlah nomor hex ke array, jadi saya meneruskan referensi ke array yang saya gunakan, dan int saya perlu dikonversi dan mengembalikan posisi relatif nomor hex berikutnya. Jadi array byte terakhir memiliki [0] jumlah pasangan hex, [1 ...] pasangan hex, kemudian jumlah pasangan ...

Berdasarkan solusi pilihan, berikut ini harus sedikit lebih efisien:

  public static byte [] hexStringToByteArray (final String s) {
    if (s == null || (s.length () % 2) == 1)
      throw new IllegalArgumentException ();
    final char [] chars = s.toCharArray ();
    final int len = chars.length;
    final byte [] data = new byte [len / 2];
    for (int i = 0; i < len; i += 2) {
      data[i / 2] = (byte) ((Character.digit (chars[i], 16) << 4) + Character.digit (chars[i + 1], 16));
    }
    return data;
  }

Karena: konversi awal ke array arang memberikan pemeriksaan panjang di charAt

Jika Anda memiliki preferensi untuk Java 8 stream sebagai gaya pengkodean Anda maka ini dapat dicapai hanya dengan menggunakan JDK primitif.

String hex = "0001027f80fdfeff";

byte[] converted = IntStream.range(0, hex.length() / 2)
    .map(i -> Character.digit(hex.charAt(i * 2), 16) << 4 | Character.digit(hex.charAt((i * 2) + 1), 16))
    .collect(ByteArrayOutputStream::new,
             ByteArrayOutputStream::write,
             (s1, s2) -> s1.write(s2.toByteArray(), 0, s2.size()))
    .toByteArray();

The , 0, s2.size()parameter dalam fungsi kolektor concatenate dapat dihilangkan jika Anda tidak keberatan penangkapan IOException.

public static byte[] hex2ba(String sHex) throws Hex2baException {
    if (1==sHex.length()%2) {
        throw(new Hex2baException("Hex string need even number of chars"));
    }

    byte[] ba = new byte[sHex.length()/2];
    for (int i=0;i<sHex.length()/2;i++) {
        ba[i] = (Integer.decode(
                "0x"+sHex.substring(i*2, (i+1)*2))).byteValue();
    }
    return ba;
}

Solusi formal saya:

/**
 * Decodes a hexadecimally encoded binary string.
 * <p>
 * Note that this function does <em>NOT</em> convert a hexadecimal number to a
 * binary number.
 *
 * @param hex Hexadecimal representation of data.
 * @return The byte[] representation of the given data.
 * @throws NumberFormatException If the hexadecimal input string is of odd
 * length or invalid hexadecimal string.
 */
public static byte[] hex2bin(String hex) throws NumberFormatException {
    if (hex.length() % 2 > 0) {
        throw new NumberFormatException("Hexadecimal input string must have an even length.");
    }
    byte[] r = new byte[hex.length() / 2];
    for (int i = hex.length(); i > 0;) {
        r[i / 2 - 1] = (byte) (digit(hex.charAt(--i)) | (digit(hex.charAt(--i)) << 4));
    }
    return r;
}

private static int digit(char ch) {
    int r = Character.digit(ch, 16);
    if (r < 0) {
        throw new NumberFormatException("Invalid hexadecimal string: " + ch);
    }
    return r;
}

Seperti fungsi PHP hex2bin () tetapi dalam gaya Java.

Contoh:

String data = new String(hex2bin("6578616d706c65206865782064617461"));
// data value: "example hex data"

Terlambat ke pesta, tetapi saya telah menggabungkan jawaban di atas oleh DaveL ke dalam kelas dengan tindakan sebaliknya - kalau-kalau itu membantu.

public final class HexString {
    private static final char[] digits = "0123456789ABCDEF".toCharArray();

    private HexString() {}

    public static final String fromBytes(final byte[] bytes) {
        final StringBuilder buf = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            buf.append(HexString.digits[(bytes[i] >> 4) & 0x0f]);
            buf.append(HexString.digits[bytes[i] & 0x0f]);
        }
        return buf.toString();
    }

    public static final byte[] toByteArray(final String hexString) {
        if ((hexString.length() % 2) != 0) {
            throw new IllegalArgumentException("Input string must contain an even number of characters");
        }
        final int len = hexString.length();
        final byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                    + Character.digit(hexString.charAt(i + 1), 16));
        }
        return data;
    }
}

Dan kelas uji JUnit:

public class TestHexString {

    @Test
    public void test() {
        String[] tests = {"0FA1056D73", "", "00", "0123456789ABCDEF", "FFFFFFFF"};

        for (int i = 0; i < tests.length; i++) {
            String in = tests[i];
            byte[] bytes = HexString.toByteArray(in);
            String out = HexString.fromBytes(bytes);
            System.out.println(in); //DEBUG
            System.out.println(out); //DEBUG
            Assert.assertEquals(in, out);

        }

    }

}

Saya tahu ini adalah utas yang sangat lama, tetapi masih ingin menambahkan nilai sen saya.

Jika saya benar-benar perlu kode hex string sederhana ke konverter biner, saya ingin melakukannya sebagai berikut.

public static byte[] hexToBinary(String s){

  /*
   * skipped any input validation code
   */

  byte[] data = new byte[s.length()/2];

  for( int i=0, j=0; 
       i<s.length() && j<data.length; 
       i+=2, j++)
  {
     data[j] = (byte)Integer.parseInt(s.substring(i, i+2), 16);
  }

  return data;
}

Sejauh ini bukan solusi terbersih. Tapi itu bekerja untuk saya dan diformat dengan baik:

private String createHexDump(byte[] msg, String description) {
    System.out.println();
    String result = "\n" + description;
    int currentIndex = 0;
    int printedIndex = 0;
    for(int i=0 ; i<msg.length ; i++){
        currentIndex++;
        if(i == 0){
            result += String.format("\n  %04x ", i);
        }
        if(i % 16 == 0 && i != 0){
            result += " | ";
            for(int j=(i-16) ; j<msg.length && j<i ; j++) {
                char characterToAdd = (char) msg[j];
                if (characterToAdd == '\n') {
                    characterToAdd = ' ';
                }
                result += characterToAdd;
                printedIndex++;
            }

            result += String.format("\n  %04x ", i);
        }

        result += String.format("%02x ", msg[i]);
    }

    if(currentIndex - printedIndex > 0){
        int leftOvers = currentIndex - printedIndex;
        for(int i=0 ; i<16-leftOvers ; i++){
            result += "   ";
        }

        result += " | ";

        for(int i=msg.length-leftOvers ; i<msg.length ; i++){
            char characterToAdd = (char) msg[i];
            if (characterToAdd == '\n') {
                characterToAdd = ' ';
            }
            result += characterToAdd;
        }
    }

    result += "\n";

    return result;
}

Hasil:

  S -> C
    0000 0b 00 2e 06 4d 6f 72 69 74 7a 53 6f 6d 65 20 54  |  .Heyyy Some T
    0010 43 50 20 73 74 75 66 66 20 49 20 63 61 70 74 75  | CP stuff I captu
    0020 72 65 64 2e 2e 77 65 6c 6c 20 66 6f 72 6d 61 74  | red..well format
    0030 3f                                               | ?

Saya pikir akan melakukannya untuk Anda. Saya menggabungkannya dari fungsi serupa yang mengembalikan data sebagai string:

private static byte[] decode(String encoded) {
    byte result[] = new byte[encoded/2];
    char enc[] = encoded.toUpperCase().toCharArray();
    StringBuffer curr;
    for (int i = 0; i < enc.length; i += 2) {
        curr = new StringBuffer("");
        curr.append(String.valueOf(enc[i]));
        curr.append(String.valueOf(enc[i + 1]));
        result[i] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

Bagi saya ini solusinya, HEX = "FF01" lalu bagi menjadi FF (255) dan 01 (01)

private static byte[] BytesEncode(String encoded) {
    //System.out.println(encoded.length());
    byte result[] = new byte[encoded.length() / 2];
    char enc[] = encoded.toUpperCase().toCharArray();
    String curr = "";
    for (int i = 0; i < encoded.length(); i=i+2) {
        curr = encoded.substring(i,i+2);
        System.out.println(curr);
        if(i==0){
            result[i]=((byte) Integer.parseInt(curr, 16));
        }else{
            result[i/2]=((byte) Integer.parseInt(curr, 16));
        }

    }
    return result;
}