How do I initialize a byte array in Java?

Question

I have to store some constant values (UUIDs) in byte array form in java, and I'm wondering what the best way to initialize those static arrays would be. This is how I'm currently doing it, but I feel like there must be a better way.

private static final byte[] CDRIVES = new byte[] { (byte)0xe0, 0x4f, (byte)0xd0,
    0x20, (byte)0xea, 0x3a, 0x69, 0x10, (byte)0xa2, (byte)0xd8, 0x08, 0x00, 0x2b,
    0x30, 0x30, (byte)0x9d };
private static final byte[] CMYDOCS = new byte[] { (byte)0xba, (byte)0x8a, 0x0d,
    0x45, 0x25, (byte)0xad, (byte)0xd0, 0x11, (byte)0x98, (byte)0xa8, 0x08, 0x00,
    0x36, 0x1b, 0x11, 0x03 };
private static final byte[] IEFRAME = new byte[] { (byte)0x80, 0x53, 0x1c,
    (byte)0x87, (byte)0xa0, 0x42, 0x69, 0x10, (byte)0xa2, (byte)0xea, 0x08,
    0x00, 0x2b, 0x30, 0x30, (byte)0x9d };
...
and so on

Is there anything I could use that may be less efficient, but would look cleaner? for example:

private static final byte[] CDRIVES =
    new byte[] { "0xe04fd020ea3a6910a2d808002b30309d" };

Since they're declared as `static final`, this might already be the most proper way; the accepted answer completely ignores these keywords and would not even work with them. — Martin Zeitler, Jan 17 '21 at 19:04

score 126 · Accepted Answer · edited May 23 '17 at 12:10

Using a function converting an hexa string to byte[], you could do

byte[] CDRIVES = hexStringToByteArray("e04fd020ea3a6910a2d808002b30309d");

I'd suggest you use the function defined by Dave L in Convert a string representation of a hex dump to a byte array using Java?

I insert it here for maximum readability :

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

If you let CDRIVES static and final, the performance drop is irrelevant.

score 90 · Answer 2 · edited Jan 30 '19 at 11:50

90

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

String literals can be escaped to provide any character:

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

edited Jan 30 '19 at 11:50

Nicolas

996
9
24

answered Jan 15 '14 at 18:50

petmez

1,393
8
4

51

Doesn't that turn the string `"0000"` to `{0x30,0x30,0x30,0x30}` (ASCII) rather than `{0x00,0x00,0x00,0x00}` (binary) as desired by the poster? – jww Aug 31 '14 at 15:57
5

Look at the question's title. Then look back at this answer. Now tell me, what's wrong about it? It might not solve the poster's particular issue, but it sure solved mine. I needed to transform a string into a byte array to use as a seed for a pseudorandom number generator and this worked like a charm. – e18r Sep 14 '18 at 15:55
@e18r It is generating bytes, yes, but you don't know which since this depence on the default charset. At least use .getBytes(desiredEncoding). – quant Feb 27 '19 at 18:25
@petmez dumb question: in JAVA, is something like "".getBytes(UTF_8)); (getBytes on an empty string) a safe thing to do? is it 'legal'? Or can I just do: = new byte[0]; ? – Robert Achmann Mar 01 '19 at 18:35
1

@RobertAchmann "".getbytes("UTF-8") should return an empty array and is perfectly legal. – Jazzepi May 06 '20 at 14:14

score 36 · Answer 3 · edited Aug 08 '16 at 15:49

36

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.

edited Aug 08 '16 at 15:49

Alexander Oh

20,413
12
65
70

answered Oct 08 '13 at 08:12

stefan.schwetschke

8,596
1
22
29

The Guava example doesn't quite work as written - it needs to be `base16().lowerCase().decode(...)` if you have lower case hex digits. http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/io/BaseEncoding.html#lowerCase() – Peter DeGlopper Sep 01 '15 at 21:43
@PeterDeGlopper Good finding, I've updated the answer so the code now handles strings with both lower and upper case characters. – stefan.schwetschke Sep 02 '15 at 07:06
1

`javax.xml.bind` was sadly removed in Java 9. – randomdude999 Jan 05 '19 at 22:02

score 7 · Answer 4 · answered Jun 26 '12 at 13:36

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.

score 4 · Answer 5 · answered Apr 19 '20 at 11:57

Smallest internal type, which at compile time can be assigned by hex numbers is char, as

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

In order to have an equivalent byte array one might deploy conversions as

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

score 3 · Answer 6 · answered Nov 10 '17 at 20:49

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

score 3 · Answer 7 · answered Nov 25 '18 at 01:11

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

Amit · Answer 8 · 2015-12-18T05:32:13.393

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.

rbrtl · Answer 9 · 2016-10-13T10:19:34.570

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:

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.
Hex.encodeHex(byte[] data) is the counterpart to the decode method above, and spits out the char[].
Hex.encodeHexString(byte[] data) which converts back from a byte array to a String.

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

score 0 · Answer 10 · answered Apr 02 '21 at 21:41

You can use the bouncy castle package,

Maven import,

  <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
    </dependency>

Java code,

byte[] CDRIVES = Hex.decode("e04fd020ea3a6910a2d808002b30309d");

score -2 · Answer 11 · answered Sep 05 '17 at 11:08

-2

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

and after access convert to byte.

answered Sep 05 '17 at 11:08

Frankie

1

How do I initialize a byte array in Java?

11 Answers11

Linked

Related