up vote 16 down vote favorite
9

since Java doesn't provide a default way to do this,

what's a fast way to convert an Integer into a Byte Array?

e.g. 0xAABBCCDD => {AA, BB, CC, DD}

share|improve this question
100% accept rate
Does it matter what format the resulting byte array is? What will you do with it? – skaffman Dec 20 '09 at 20:27
feedback

4 Answers

up vote 37 down vote accepted

Have a look at the ByteBuffer class.

ByteBuffer b = ByteBuffer.allocate(4);
//b.order(ByteOrder.BIG_ENDIAN); // optional, the initial order of a byte buffer is always BIG_ENDIAN.
b.putInt(0xAABBCCDD);

byte[] result = b.array();

Setting the byte order ensures that result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCC and result[3] == 0xDD.

Or alternatively, you could do it manually:

byte[] toBytes(int i)
{
  byte[] result = new byte[4];

  result[0] = (byte) (i >> 24);
  result[1] = (byte) (i >> 16);
  result[2] = (byte) (i >> 8);
  result[3] = (byte) (i /*>> 0*/);

  return result;
}

The ByteBuffer class was designed for such dirty hands tasks though. In fact the private java.nio.Bits defines these helper methods that are used by ByteBuffer.putInt():

private static byte int3(int x) { return (byte)(x >> 24); }
private static byte int2(int x) { return (byte)(x >> 16); }
private static byte int1(int x) { return (byte)(x >>  8); }
private static byte int0(int x) { return (byte)(x >>  0); }
share|improve this answer
2  
this would work well if the bytebuffer is already there... otherwise it seems like it would take longer to do the allocation, than to just allocate a byte array of length 4 and do the shifting manually... but we're probably talking about small differences. – Jason S Dec 20 '09 at 20:24
3  
get it right first, then profile, then optimize ;) – Gregory Pakosz Dec 20 '09 at 20:27
The ByteBuffer instance can be cached; and internally it's surely implemented with shifting and masking anyway. – Gregory Pakosz Dec 20 '09 at 20:30
1  
This is a perfectly fine answer. Note that big-endian is the specified default, and the methods are "chainable", and the position argument is optional, so it all reduces to: byte[] result = ByteBuffer.allocate(4).putInt(0xAABBCCDD).array(); Of course, if you're doing this repeatedly and concatenating all the results together (which is common when you're doing this kind of thing), allocate a single buffer and repeatedly putFoo() all the things into it that you need -- it will keep track of the offset as you go. It's really a tremendously useful class. – Kevin Bourrillion Dec 22 '09 at 1:06
@Kevin, thank you – Gregory Pakosz Dec 22 '09 at 10:20
show 2 more comments
feedback
up vote 2 down vote

use this function it works for me

public byte[] intToByteArray(int value) {
    return new byte[] {
            (byte)(value >>> 24),
            (byte)(value >>> 16),
            (byte)(value >>> 8),
            (byte)value};
}

it translates the int into a byte value

share|improve this answer
It's also worth nothing that this will work regardless of the most significant bit and more efficient compared to the other answers. Also could use '>>'. – algolicious Jul 23 at 15:20
feedback
up vote 2 down vote

You can use BigInteger:

From Integers:

byte[] array = BigInteger.valueOf(0xAABBCCDD).toByteArray();
System.out.println(Arrays.toString(array))
// --> {-86, -69, -52, -35 }

The returned array is of the size that is needed to represent the number, so it could be of size 1, to represent 1 for example. However, the size cannot be more than four bytes if an int is passed.

From Strings:

BigInteger v = new BigInteger("AABBCCDD", 16);
byte[] array = v.toByteArray();

However, you will need to watch out, if the first byte is higher 0x7F (as is in this case), where BigInteger would insert a 0x00 byte to the beginning of the array. This is needed to distinguish between positive and negative values.

share|improve this answer
thanks! But since this is BigInteger, will ints wrap around correctly? That is integers that are outside Integer.MAX_VALUE but can still be represented with only 4 bytes? – Buttercup Dec 20 '09 at 20:22
This is certainly not fast to execute. ;) – Peter Lawrey Dec 20 '09 at 20:24
This is not a good option. Not only it may add 0x00 byte, it may also strip leading zeros. – ZZ Coder Dec 20 '09 at 20:26
feedback
up vote 5 down vote

Using BigInteger:

private byte[] bigIntToByteArray( final int i ) {
    BigInteger bigInt = BigInteger.valueOf(i);      
    return bigInt.toByteArray();
}

Using DataOutputStream:

private byte[] intToByteArray ( final int i ) throws IOException {  	
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(bos);
    dos.writeInt(i);
    dos.flush();
    return bos.toByteArray();
}

Using ByteBuffer:

public byte[] intToBytes( final int i ) {
    ByteBuffer bb = ByteBuffer.allocate(4); 
    bb.putInt(i); 
    return bb.array();
}
share|improve this answer
1  
pay attention to the byte order though – Gregory Pakosz Dec 20 '09 at 20:32
feedback

Your Answer

 
or
required, but never shown
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.