Wsrtjtyk

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

String literals can be escaped to provide any character:

byte CDRIVES = "u00e0u004fu00d0u0020u00eau003au0069u0010u00a2u00d8u0008u0000u002bu0030u0030u009d".getBytes();

In Java 6, there is a method doing exactly what you want:

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

Alternatively you could use Google Guava:

import com.google.common.io.BaseEncoding;

private static final byte CDRIVES = BaseEncoding.base16().lowerCase().decode("E04FD020ea3a6910a2d808002b30309d".toLowerCase());

The Guava method is overkill, when you are using small arrays. But Guava has also versions that can parse input streams. This is a nice feature when dealing with big hexadecimal inputs.

You can use the Java UUID class to store these values, instead of byte arrays:

UUID



public UUID(long mostSigBits,

            long leastSigBits)

Constructs a new UUID using the specified data. mostSigBits is used for the most significant 64 bits of the UUID and leastSigBits becomes the least significant 64 bits of the UUID.

As far as a clean process is concerned you can use ByteArrayOutputStream object...

ByteArrayOutputStream bObj = new ByteArrayOutputStream();

bObj.reset();

//write all the values to bObj one by one using

bObj.write(byte value)

// when done you can get the byte using

CDRIVES = bObj.toByteArray();

//than you can repeat the similar process for CMYDOCS and IEFRAME as well,

NOTE This is not an efficient solution if you really have small array.

My preferred option in this circumstance is to use org.apache.commons.codec.binary.Hex which has useful APIs for converting between Stringy hex and binary. For example:

1. Hex.decodeHex(char data) which throws a DecoderException if there are non-hex characters in the array, or if there are an odd number of characters.




2. Hex.encodeHex(byte data) is the counterpart to the decode method above, and spits out the char.




3. Hex.encodeHexString(byte data) which converts back from a byte array to a String.

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

A solution with no libraries, dynamic length returned, unsigned integer interpretation (not two's complement)

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

    }

}

You can use this utility function:

public static byte fromHexString(String src) {

    byte biBytes = new BigInteger("10" + src.replaceAll("\s", ""), 16).toByteArray();

    return Arrays.copyOfRange(biBytes, 1, biBytes.length);

}

Unlike variants of Denys Séguret and stefan.schwetschke, it allows inserting separator symbols (spaces, tabs, etc.) into the input string, making it more readable.

Example of usage:

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

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

and after access convert to byte.