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


Need Your Help

vs 2010: error LNK2028: unresolved token (0A000342) "extern "C" int __stdcall

windows winforms visual-studio-2010

The following code is taken from here. I removed all Windows NT part as I am working on Windows 7.

How to understand the JavaScript code generated by CoffeeScript's `extends` keyword

javascript coffeescript prototypal-inheritance

This is the JavaScript code generated by CoffeeScript's extends keyword. How the prototype chain gets setup?