Tutorial :How to convert a byte array to its numeric value (Java)? Question:

I have an 8 byte array and I want to convert it to its corresponding numeric value.

e.g.

``byte[] by = new byte;  // the byte array is stored in 'by'    // CONVERSION OPERATION  // return the numeric value  ``

I want a method that will perform the above conversion operation.

Solution:1

Assuming the first byte is the least significant byte:

``long value = 0;  for (int i = 0; i < by.length; i++)  {     value += ((long) by[i] & 0xffL) << (8 * i);  }  ``

Is the first byte the most significant, then it is a little bit different:

``long value = 0;  for (int i = 0; i < by.length; i++)  {     value = (value << 8) + (by[i] & 0xff);  }  ``

Replace long with BigInteger, if you have more than 8 bytes.

Thanks to Aaron Digulla for the correction of my errors.

Solution:2

One could use the `Buffer`s that are provided as part of the `java.nio` package to perform the conversion.

Here, the source `byte[]` array has a of length 8, which is the size that corresponds with a `long` value.

First, the `byte[]` array is wrapped in a `ByteBuffer`, and then the `ByteBuffer.getLong` method is called to obtain the `long` value:

``ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 0, 0, 0, 0, 4});  long l = bb.getLong();    System.out.println(l);  ``

Result

``4  ``

I'd like to thank dfa for pointing out the `ByteBuffer.getLong` method in the comments.

Although it may not be applicable in this situation, the beauty of the `Buffer`s come with looking at an array with multiple values.

For example, if we had a 8 byte array, and we wanted to view it as two `int` values, we could wrap the `byte[]` array in an `ByteBuffer`, which is viewed as a `IntBuffer` and obtain the values by `IntBuffer.get`:

``ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 1, 0, 0, 0, 4});  IntBuffer ib = bb.asIntBuffer();  int i0 = ib.get(0);  int i1 = ib.get(1);    System.out.println(i0);  System.out.println(i1);  ``

Result:

``1  4  ``

Solution:3

If this is an 8-bytes numeric value, you can try:

``BigInteger n = new BigInteger(byteArray);  ``

If this is an UTF-8 character buffer, then you can try:

``BigInteger n = new BigInteger(new String(byteArray, "UTF-8"));  ``

Solution:4

Simply, you could use or refer to guava lib provided by google, which offers utiliy methods for conversion between long and byte array. My client code:

``    long content = 212000607777l;      byte[] numberByte = Longs.toByteArray(content);      logger.info(Longs.fromByteArray(numberByte));  ``

Solution:5

You can also use BigInteger for variable length bytes. You can convert it to Long, Integer or Short, whichever suits your needs.

``new BigInteger(bytes).intValue();  ``

or to denote polarity:

``new BigInteger(1, bytes).intValue();  ``

Solution:6

Complete java converter code for all primitive types to/from arrays http://www.daniweb.com/code/snippet216874.html

Solution:7

Each cell in the array is treated as unsigned int:

``private int unsignedIntFromByteArray(byte[] bytes) {  int res = 0;  if (bytes == null)      return res;      for (int i=0;i<bytes.length;i++){      res = res | ((bytes[i] & 0xff) << i*8);  }  return res;  }  ``

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »