Konvertieren einer Zeichenfolgendarstellung eines Hex-Dumps mit Java in ein Byte-Array?

Ich suche nach einer Möglichkeit, eine lange Zeichenfolge (aus einem Speicherauszug), die Hex-Werte darstellt, in ein Byte-Array umzuwandeln.

Ich hätte es nicht besser formulieren können als die Person, die hier dieselbe Frage gestellt hat .

Aber um es original zu halten, werde ich es auf meine eigene Weise formulieren: Angenommen, ich habe eine Zeichenfolge "00A0BF", die ich gerne als die interpretieren würde

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

was sollte ich tun?

Ich bin ein Java-Neuling und habe am Ende BigIntegerführende Hex-Nullen verwendet und darauf geachtet. Aber ich finde es hässlich und ich bin mir sicher, dass mir etwas Einfaches fehlt.

Hier ist eine Lösung, die meiner Meinung nach besser ist als jede bisher veröffentlichte:

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

Gründe, warum es eine Verbesserung ist:

• Sicher mit führenden Nullen (im Gegensatz zu BigInteger) und mit negativen Bytewerten (im Gegensatz zu Byte.parseByte)

• Konvertiert den String nicht in ein char[]oder erstellt StringBuilder- und String-Objekte für jedes einzelne Byte.

• Keine Bibliotheksabhängigkeiten, die möglicherweise nicht verfügbar sind

Sie können die Argumentprüfung über assertoder Ausnahmen hinzufügen, wenn nicht bekannt ist, dass das Argument sicher ist.

Einzeiler:

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

Warnungen :

• In Java 9 Jigsaw ist dies nicht mehr Teil des (Standard-) java.se-Stammsatzes, sodass eine ClassNotFoundException ausgelöst wird, sofern Sie nicht --add-modules java.se.ee angeben (danke an @ eckes).
• Nicht verfügbar für Android (danke Fabiandafür), aber Sie können einfach den Quellcode verwenden, wenn Ihr System javax.xmlaus irgendeinem Grund fehlt . Vielen Dank an @ Bert Regelinkfür das Extrahieren der Quelle.

Die Hex-Klasse im Commons-Codec sollte das für Sie tun.

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

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

Sie können jetzt BaseEncoding in verwenden guava, um dies zu erreichen.

BaseEncoding.base16().decode(string);

Um es umzukehren, verwenden Sie

BaseEncoding.base16().encode(bytes);

Eigentlich finde ich die BigInteger-Lösung sehr schön:

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

Bearbeiten: Nicht sicher für führende Nullen , wie auf dem Poster angegeben.

Einzeiler:

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

Für diejenigen unter Ihnen, die sich für den eigentlichen Code hinter den Einzeilern von FractalizeR interessieren (ich brauchte das, da javax.xml.bind für Android nicht verfügbar ist (standardmäßig)), kommt dieser von 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();
}

Das HexBinaryAdapterbietet die Möglichkeit, zwischen Stringund zu marshallen und zu marshallen byte[].

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

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

Das ist nur ein Beispiel, das ich eingegeben habe ... Ich verwende es einfach so wie es ist und muss keine separate Methode für die Verwendung erstellen.

Hier ist eine Methode, die tatsächlich funktioniert (basierend auf mehreren vorherigen halbkorrekten Antworten):

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

Das einzig mögliche Problem, das ich sehen kann, ist, ob die Eingabezeichenfolge extrem lang ist. Durch Aufrufen von toCharArray () wird eine Kopie des internen Arrays der Zeichenfolge erstellt.

EDIT: Oh, und übrigens, Bytes sind in Java signiert, also wird Ihre Eingabezeichenfolge in [0, -96, -65] anstelle von [0, 160, 191] konvertiert. Aber das wusstest du wahrscheinlich schon.

In Android, wenn Sie mit Hex arbeiten, können Sie okio versuchen .

einfache Verwendung:

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

und Ergebnis wird sein

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

Die BigInteger()Methode von java.math ist sehr langsam und nicht empfehlenswert.

Integer.parseInt(HEXString, 16)

kann bei einigen Zeichen Probleme verursachen, ohne in Digit / Integer zu konvertieren

eine gut funktionierende Methode:

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

Funktion:

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

Viel Spaß, viel Glück

BEARBEITEN: Wie von @mmyers hervorgehoben, funktioniert diese Methode nicht bei Eingaben, die Teilzeichenfolgen enthalten, die Bytes mit gesetztem High-Bit ("80" - "FF") entsprechen. Die Erklärung finden Sie unter Fehler-ID: 6259307 Byte.parseByte funktioniert nicht wie in der SDK-Dokumentation angegeben .

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

Für das, was es wert ist, ist hier eine andere Version, die Zeichenfolgen mit ungerader Länge unterstützt, ohne auf die Verkettung von Zeichenfolgen zurückzugreifen.

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

Ich habe immer eine Methode wie verwendet

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

Diese Methode teilt auf durch Leerzeichen getrennte Hex-Werte auf, aber es wäre nicht schwierig, die Zeichenfolge nach anderen Kriterien aufzuteilen, z. B. in Gruppierungen von zwei Zeichen.

Ich mag die Character.digit-Lösung, aber hier ist, wie ich sie gelöst habe

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

Der von Bert Regelink vorgelegte Kodex funktioniert einfach nicht. Versuche Folgendes:

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

Ich fand, dass Kernel Panic die für mich nützlichste Lösung hat, stieß jedoch auf Probleme, wenn die Hex-Zeichenfolge eine ungerade Zahl war. löste es so:

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

Ich füge einem Array eine Anzahl von Hex-Zahlen hinzu, also übergebe ich den Verweis auf das Array, das ich verwende, und das Int, das ich konvertieren muss, und gebe die relative Position der nächsten Hex-Nummer zurück. Das letzte Byte-Array hat also [0] Anzahl von Hex-Paaren, [1 ...] Hex-Paare, dann die Anzahl von Paaren ...

Basierend auf der op-Voted-Lösung sollte Folgendes etwas effizienter sein:

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

Denn: Die anfängliche Konvertierung in ein char-Array erspart die Längenprüfungen in charAt

Wenn Sie Java 8-Streams als Codierungsstil bevorzugen, können Sie dies nur mit JDK-Grundelementen erreichen.

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

Die , 0, s2.size()Parameter in der Collector-Verkettungsfunktion können weggelassen werden, wenn Sie nichts dagegen haben, zu fangen 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;
}

Meine formale Lösung:

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

Ist wie die PHP hex2bin () Funktion, aber im Java-Stil.

Beispiel:

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

Spät zur Party, aber ich habe die obige Antwort von DaveL zu einer Klasse mit umgekehrter Aktion zusammengefasst - nur für den Fall, dass es hilft.

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

Und JUnit-Testklasse:

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

        }

    }

}

Ich weiß, dass dies ein sehr alter Thread ist, aber ich möchte immer noch meinen Penny hinzufügen.

Wenn ich wirklich eine einfache Hex-Zeichenfolge in einen Binärkonverter codieren muss, möchte ich dies wie folgt tun.

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

Bei weitem nicht die sauberste Lösung. Aber es funktioniert bei mir und ist gut formatiert:

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

Die Ausgabe:

  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                                               | ?

Ich denke, ich werde es für dich tun. Ich habe es aus einer ähnlichen Funktion zusammengeschustert, die die Daten als Zeichenfolge zurückgegeben hat:

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

Für mich war dies die Lösung, HEX = "FF01", dann aufgeteilt in FF (255) und 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;
}