# How do I determine number of bytes needed to represent a given integer?

I need a function in Java to give me number of bytes needed to represent a given integer. When I pass 2 it should return 1, 400 -> 2, 822222 -> 3, etc.

@Edit: For now I'm stuck with this:

numOfBytes = Integer.highestOneBit(integer) / 8

Don't know exactly what highestOneBit() does, but have also tried this:

numOfBytes = (int) (Math.floor(Math.log(integer)) + 1);

Which I found on some website.

## Answers

static int byteSize(long x) { if (x < 0) throw new IllegalArgumentException(); int s = 1; while (s < 8 && x >= (1L << (s * 8))) s++; return s; }

Integer.highestOneBit(arg) returns only the highest set bit, in the original place. For example, Integer.highestOneBit(12) is 8, not 3. So you probably want to use Integer.numberOfTrailingZeros(Integer.highestOneBit(12)), which does return 3. Here is the Integer API

Some sample code:

numOfBytes = (Integer.numberOfTrailingZeroes(Integer.highestOneBit(integer)) + 8) / 8;

The + 8 is for proper rounding.

The lazy/inefficient way to do this is with Integer#toBinaryString. It will remove all leading zeros from positive numbers for you, all you have to do is call String#length and divide by 8.

Think about how to solve the same problem using normal decimal numbers. Then apply the same principle to binary / byte representation i.e. use 256 where you would use 10 for decimal numbers.

static int byteSize(long number, int bitsPerByte) { int maxNumberSaveByBitsPerByte = // get max number can be saved by bits in value bitsPerByte int returnValue = getFloor(number/maxNumberSaveByBitsPerByte); // use Math lib if(number % maxNumberSaveByBitsPerByte != 0) returnValue++; return returnValue; }

For positive values: 0 and 1 need 1 digit, with 2 digits you get the doubled max value, and for every digit it is 2 times that value. So a recursive solution is to divide:

public static int binaryLength (long l) { if (l < 2) return 1; else 1 + binaryLength (l /2L); }

but shifting works too:

public static int binaryLength (long l) { if (l < 2) return 1; else 1 + binaryLength (l >> 1); }

Negative values have a leading 1, so it doesn't make much sense for the question. If we assume binary1 is decimal1, binary1 can't be -1. But what shall it be? b11? That is 3.

Why you wouldn't do something simple like this:

private static int byteSize(int val) { int size = 0; while (val > 0) { val = val >> 8; size++; } return size; }

int numOfBytes = (Integer.SIZE >> 3) - (Integer.numberOfLeadingZeros(n) >> 3);

This implementation is compact enough while performance-friendly, since it doesn't involve any floating point operation nor any loop.

It is derived from the form:

int numOfBytes = Math.ceil((Integer.SIZE - Integer.numberOfLeadingZeros(n)) / Byte.SIZE);

The magic number 3 in the optimized form comes from the assumption: Byte.SIZE equals 8