Comment initialiser un tableau d'octets en Java?

byte[] myvar = "Any String you want".getBytes();

Les littéraux de chaîne peuvent être échappés pour fournir n'importe quel caractère:

byte[] CDRIVES = "\u00e0\u004f\u00d0\u0020\u00ea\u003a\u0069\u0010\u00a2\u00d8\u0008\u0000\u002b\u0030\u0030\u009d".getBytes();

Dans Java 6, il existe une méthode faisant exactement ce que vous voulez:

private static final byte[] CDRIVES = javax.xml.bind.DatatypeConverter.parseHexBinary("e04fd020ea3a6910a2d808002b30309d")

Sinon, vous pouvez utiliser Google Goyave:

import com.google.common.io.BaseEncoding;
private static final byte[] CDRIVES = BaseEncoding.base16().lowerCase().decode("E04FD020ea3a6910a2d808002b30309d".toLowerCase());

La méthode Goyave est exagérée, lorsque vous utilisez de petits tableaux. Mais Guava a aussi des versions qui peuvent analyser les flux d'entrée. C'est une fonctionnalité intéressante lorsqu'il s'agit de grandes entrées hexadécimales.

Vous pouvez utiliser la classe Java UUID pour stocker ces valeurs, au lieu des tableaux d'octets:

UUID

public UUID(long mostSigBits,
            long leastSigBits)

Construit un nouvel UUID en utilisant les données spécifiées. mostSigBits est utilisé pour les 64 bits les plus significatifs de l'UUID et leastSigBits devient les 64 bits les moins significatifs de l'UUID.

Une solution sans bibliothèques, longueur dynamique renvoyée, interprétation entière non signée (pas le complément de deux)

    public static byte[] numToBytes(int num){
    if(num == 0){
        return new byte[]{};
    }else if(num < 256){
        return new byte[]{ (byte)(num) };
    }else if(num < 65536){
        return new byte[]{ (byte)(num >>> 8),(byte)num };
    }else if(num < 16777216){
        return new byte[]{ (byte)(num >>> 16),(byte)(num >>> 8),(byte)num };
    }else{ // up to 2,147,483,647
        return new byte[]{ (byte)(num >>> 24),(byte)(num >>> 16),(byte)(num >>> 8),(byte)num };
    }
}

Le plus petit type interne, qui au moment de la compilation peut être attribué par des nombres hexadécimaux est char , as

private static final char[] CDRIVES_char = new char[] {0xe0, 0xf4, ...};

Pour avoir un tableau d'octets équivalent, on peut déployer des conversions comme

public static byte[] charToByteArray(char[] x)
{
    final byte[] res = new byte[x.length];
    for (int i = 0; i < x.length; i++)
    {
        res[i] = (byte) x[i];
    }
    return res;
}

public static byte[][] charToByteArray(char[][] x)
{
    final byte[][] res = new byte[x.length][];
    for (int i = 0; i < x.length; i++)
    {
        res[i] = charToByteArray(x[i]);
    }
    return res;
}

En ce qui concerne un processus propre, vous pouvez utiliser ByteArrayOutputStream objet...

ByteArrayOutputStream bObj = new ByteArrayOutputStream();
bObj.reset();

//écrivez toutes les valeurs à bObj une par une en utilisant

bObj.write(byte value)

/ / lorsque vous avez terminé, vous pouvez obtenir l'octet [] en utilisant

CDRIVES = bObj.toByteArray();

/ / que vous pouvez répéter le processus similaire pour CMYDOCS et IEFRAME ainsi,

REMARQUE Ce n'est pas une solution efficace si vous avez vraiment un petit tableau.

Vous pouvez utiliser cette fonction utilitaire:

public static byte[] fromHexString(String src) {
    byte[] biBytes = new BigInteger("10" + src.replaceAll("\\s", ""), 16).toByteArray();
    return Arrays.copyOfRange(biBytes, 1, biBytes.length);
}

Contrairement aux variantes de Denys Séguret et stefan.schwetschke, il permet d'insérer des symboles de séparation (espaces, onglets, etc.) dans la chaîne d'entrée, la rendant plus lisible.

Exemple d'utilisation:

private static final byte[] CDRIVES
    = fromHexString("e0 4f d0 20 ea 3a 69 10 a2 d8 08 00 2b 30 30 9d");
private static final byte[] CMYDOCS
    = fromHexString("BA8A0D4525ADD01198A80800361B1103");
private static final byte[] IEFRAME
    = fromHexString("80531c87 a0426910 a2ea0800 2b30309d");

Mon option préférée dans cette circonstance est d'utiliser org.apache.commons.codec.binary.Hex qui a des Api pour convertir entre Stringy hexadécimal et en binaire. Par exemple:

1. Hex.decodeHex(char[] data) qui lance un DecoderException s'il y a des caractères non hexadécimaux dans le tableau, ou s'il y a un nombre impair de caractères.

2. Hex.encodeHex(byte[] data) est la contrepartie de la décoder méthode ci-dessus, et crache le char[].

3. Hex.encodeHexString(byte[] data) qui convertit arrière à partir d'un byte tableau à une String.

Utilisation: Hex.decodeHex("dd645a2564cbe648c8336d2be5eafaa6".toCharArray())

private static final int[] CDRIVES = new int[] {0xe0, 0xf4, ...};

Et après l'accès convertir en octet.