How to convert java long to 4 bytes data

By , last updated November 2, 2016

Java doesn’t have unsigned types. In order to convert C++ unsigned values to Java you may need to use larger types. Authors of the language explain it as the Java should be a simple language and be easy to understand for all developers.

Problems occur when you need to convert to or from Java numeric types. Let us look at C++ vs Java types:

C++ Type *) Java Type
8-bit unsigned byte (signed) byte
16-bit unsigned short (signed) short
32-bit unsigned int (signed) int
32-bit/64-bit unsigned long (signed) long
32-bit float float
64-bit double double

*) With C++, the types aren’t as rigidly defined in Java. The only requirement is that a char is not larger than a short, a short is not larger than an int, and an int is not larger than a long, where a short may not be smaller than 16-bits, an int may not be smaller than 32-bits and a long long at least 64-bits. It’s perfectly valid for a C++ system where are types are 64-bits.

Most of the time you don’t need to use larger numeric types.

Convert unsigned int to Integer and back

Example of the simplest case of conversion between C++ unsigned int coded bytes to Java Integer:

1. Read 4 bytes into an Integer

 
int length = ByteBuffer.wrap(bytes, 0, 4).getInt();

2. Convert Integer value to 4 bytes:

 
final byte[] bytes = intToByte(length);

private static byte[] intToByte(int value) {
	return ByteBuffer.allocate(4).putInt(value).array();
}

Convert unsigned int to long and back to 4 bytes data

In case when you need to account for all possible values of unsigned values in Java, you should convert from unsigned type to a larger numeric type and back.

Read also  Building GCC with Concepts Lite

Example of converting a C++ unsigned int to Java long: C++ layer converts unsigned int values to 4 bytes and sends it to Java layer. Java layer converts bytes to long type, analyses the data and sends the response, converting long back to 4 bytes data.

1. Read the 4 bytes and store them as long:

 
long length= ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getInt() & 0xFFFFFFFFL;

2. Convert Java long value back to 4 bytes data array:

 
final byte[] bytes = longToByte(length);

public static byte[] longToByte(long value)
{
	byte [] data = new byte[4];
	data[3] = (byte) value;
	data[2] = (byte) (value >>> 8);
	data[1] = (byte) (value >>> 16);
	data[0] = (byte) (value >>> 32);

	return data;
}

Note, you can’t use a ByteBuffer here to convert Java long to 4 bytes. Java long is stored as 8 bytes and ByteBuffer will return an 8-bytes array. You need to use bitwise operations in order to set values back to 4 bytes array.

Little endian and big endian

This post doesn’t take into account there are at least three types of endian-ness. Little endian as most Intel CPUs, big endian and then there is middle endian. Implementing those are left as an excercise for the reader.

Comments

  1. Said November 1, 2016 Leave a Reply

    2. Convert Java long value back to 4 bytes data array:
    data[0] should be equal to;
    data[0] = (byte) (value >>> 24);
    24 shift instead of 32.

Leave a Reply


You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

*