Java byte arrays and copying ints into them

Question

What's the best way to put an int at a certain point in a byte[] array?

Say you have a byte array:

byte[] bytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int someInt = 12355; //0x43, 0x30

How can I do like bytes[4] = someInt; so that now bytes[4] will equal 0x43 and bytes[5] will be equal to 0x30?

I'm used to just using memcpy with C++ and don't know the alternatives in Java.

Thanks

Answer 1

If you want also high 0-bytes of the int put into the byte[]:

void place(int num, byte[] store, int where){
    for(int i = 0; i < 4; ++i){
        store[where+i] = (byte)(num & 0xFF);
        num >>= 8;
    }
}

If you only want the bytes to the highest nonzero byte:

void place(int num, byte[] store, int where){
    while(num != 0){
        store[where++] = (byte)(num & 0xFF);
        num >>>= 8;
    }
}

If you want the bytes big-endian (highest byte at lowest index), the version storing all four bytes is very easy, the other one slightly more difficult:

void placeBigEndian(int num , byte[] store, int where){
    for(int i = 3; i >= 0; --i){
        store[where+i] = (byte)(num & 0xFF);
        num >>= 8;
    }
}

void placeBigEndian(int num, byte[] store, int where){
    in mask = 0xFF000000, shift = 24;
    while((mask & num) == 0){
        mask >>>= 8;
        shift -= 8;
    }
    while(shift > 0){
        store[where++] = (byte)((num & mask) >>> shift);
        mask >>>= 8;
        shift -= 8;
    }
}

Answer 2

Note, you assume a big endian ordering! x86 is little endian... What's more, your int is 32bits long, hence 0x00004330 in big endian.

If this is what you want, use a ByteBuffer (which uses big endian ordering by default):

ByteBuffer buf = ByteBuffer.allocate(8);
// then use buf.putInt(yourint, index)
// buf.get(index) will read byte at index index, starting from 0

Answer 3

I don't see the problem, it looks like you solved it your own way:

public static void putShort(bytes[] array, int position, short value)
{
    byte leftByte = (byte) (value >>> 8);
    byte rightByte = (byte) (value & 0xFF);

    array[position] = leftByte;
    array[position + 1] = rightByte;
}

Note that an int is 4 bytes and a short is 2 bytes.

Answer 4

First of all, in Java you don't need to initialize byte arrays to zeroes. All arrays are initialized on construction time to 0/false/null.

Second, ints are signed 32-bit big-endian integers, so 12355 is actually 0x00003043. If you want to use 16-bit integers, use the short type.

Then, to get the individual bytes in your integer, you could do:

bytes[ i ]   = (byte) (someInt >> 24);
bytes[ i+1 ] = (byte) (someInt >> 16);
bytes[ i+2 ] = (byte) (someInt >> 8);
bytes[ i+3 ] = (byte) (someInt);

The conversion to byte truncates the remaining bits, so no & 0xFF mask is needed. I'm assuming i is the index of the array. To change the endianness, swap the offsets at the indices.

Answer 5

One approach would be to use a DataOutputStream and it's writeInt() method, wrapped around a ByteArrayOutputStream. e.g. (with no error-handling)

public byte[] writeIntAtPositionX(int position, int iVal) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      DataOutputStream dos = new DataOutputStream(baos);

      // now, advancing to a specific spot is awkward.
      // presumably you are actually writing other stuff out before the integer
      // but if you really want to advance to a specific position

      for (int i = 0; i < position; i++)
         dos.writeByte(0);

      dos.writeInt(iVal);

      dos.flush();
      dos.close();
      return baos.toByteArray();  
   }

The big advantage of this method is that the guys who wrote Java figured out the byte ordering and the masking with 0xFF and all that stuff. Plus, if you ever envision writing doubles, shorts, longs or Strings etc. to your buffer you won't need to add all those methods, the work is already done.