Konvertiert einen string von hex-dump zu einem byte-array mithilfe von Java?

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-Stichsäge dies ist nicht mehr Teil des (Standard -) java.se root
  gesetzt also, es wird eine ClassNotFoundException, wenn Sie angeben,
  --add-Module java.se.ee (Dank an @eckes)
• Nicht verfügbar auf Android (Dank Fabian für erwähnenswert, dass), aber Sie können nur nehmen Sie den source-code wenn Ihr system fehlt javax.xml aus irgendeinem Grund. Dank @Bert Regelink für das extrahieren der Quelle.

InformationsquelleAutor Vladislav Rastrusny

Können Sie jetzt mit BaseEncoding in guava um dies zu erreichen.

BaseEncoding.base16().decode(string);

Rückgängig zu machen verwenden Sie

BaseEncoding.base16().encode(bytes);

InformationsquelleAutor jontro

Den HexBinaryAdapter bietet die Möglichkeit, marshal und unmarshal zwischen String und 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...ich eigentlich nur benutzen und nicht brauchen, um eine separate Methode für die Verwendung.

InformationsquelleAutor GrkEngineer

Hier ist eine Methode, die tatsächlich funktioniert (basiert auf mehreren früheren halb-richtige 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 einzige mögliche Problem, das ich sehen kann, wenn der input-string ist extrem lang; der Aufruf toCharArray() gibt eine Kopie des string s interne array.

EDIT: Oh, und übrigens, sind die bytes unterzeichnet in Java, so dass Ihr input-string konvertiert zu [0, -96, -65] anstelle von [0, 160, 191]. Aber Sie wusste wohl, dass bereits.

InformationsquelleAutor Michael Myers

EDIT: wie bereits von @mmyers, diese Methode funktioniert nicht auf Eingaben mit Teilstrings entsprechende Byte mit dem high-bit gesetzt ("80" - "FF"). Die Erklärung ist an Bug ID: 6259307 Byte.parseByte nicht wie beworben in der SDK-Dokumentation.

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

InformationsquelleAutor Blair Conrad

Den Code von Bert Regelink einfach nicht funktioniert.
Versuchen Sie 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);
        }
    }

InformationsquelleAutor Sean Coffey

Habe ich immer eine Methode wie

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 spaltet auf Leerzeichen als Trennzeichen hex-Werte, aber es wäre nicht schwer zu machen, teilen Sie die Zeichenfolge auf anderen Kriterien wie in Gruppierungen von zwei Zeichen.

InformationsquelleAutor pfranza

Fand ich Kernel Panic-die Lösung, die die meisten hilfreich für mich, aber lief in Probleme, wenn der hex-string eine ungerade Zahl. löste es auf diese Weise:

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 bin das hinzufügen einer Anzahl von hex-zahlen in ein array, so dass ich übergeben Sie die Referenz auf das array, die ich verwende, und die int Brauch ich konvertiert und gibt die relative position des nächsten hex-Zahl. Also das Letzte byte array [0] Anzahl der hex-Paare, [1...] hex-Paare, dann die Anzahl der Paare...

InformationsquelleAutor Clayton Balabanov

Wenn Sie haben eine Vorliebe für Java 8 streams als Ihre coding-Stil, dann kann dies erreicht werden, mit nur JDK primitiven.

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

Den , 0, s2.size() Parameter in der collector ' verketten-Funktion kann weggelassen werden, wenn Sie nichts dagegen haben, fangen IOException.

InformationsquelleAutor Andy Brown

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, sondern in Java-Stil.

Beispiel:

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

InformationsquelleAutor Daniel De León

Spät zur party, aber ich habe eingemeindet, die Antwort oben von DaveL in eine Klasse mit umgekehrter Handlung - nur, falls 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-test-Klasse:

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

        }

    }

}

InformationsquelleAutor DrPhill

Denke ich, wird es für Sie tun. Ich gepflasterten es zusammen aus einer ähnlichen Funktion, dass die Daten zurückgegeben, als ein 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;
}

InformationsquelleAutor Bob King