Узнайте, что число битов должно было представить положительное целое число в двоичном файле?

(int) Math.ceil((Math.log(n) / Math.log(2))

Конечно, это только работает на положительные целые числа.

Если Вы стараетесь избегать цикла, и Вы заботитесь о скорости, можно использовать метод как это:

int value = ...;
int count = 0;
if( value < 0 ) { value = 0; count = 32; }
if( value >= 0x7FFF ) { value >>= 16; count += 16; }
if( value >= 0x7F ) { value >>= 8; count += 8; }
if( value >= 0x7 ) { value >>= 4; count += 4; }
if( value >= 0x3 ) { value >>= 2; count += 2; }
if( value >= 0x1 ) { value >>= 1; count += 1; }

Java не имеет целых чисел без знака, так, чтобы сначала, если (значение <0) немного сомнительно. Отрицательные числа всегда устанавливают старший значащий бит, так возможно требуют полного слова к представить их. Адаптируйте то поведение, если Вы заботитесь.

Кстати, для обработки 64-разрядного целого числа замените если (значение <0) строка с этими двумя:

if( value < 0 ) { value = 0; count = 64; }
if( value >= 0x7FFFFFFF ) { value >>= 32; count += 32; }

Это находится в C, но я подозреваю, что Вы могли преобразовать в Java довольно легко:

Найдите, что журнал основывает 2 из целого числа N-bit в O (LG (N)) операции

Взятие двух базирующихся журналов числа сообщит о числе битов, требуемых сохранить его.

Integer.toBinaryString (число) .length ();

Хорошее горе..., почему вниз голосует?

public class Main
{
    public static void main(final String[] argv)
    {
        System.out.println(Integer.toBinaryString(0).length());
        System.out.println(Integer.toBinaryString(1).length());
        System.out.println(Integer.toBinaryString(2).length());
        System.out.println(Integer.toBinaryString(3).length());
        System.out.println(Integer.toBinaryString(4).length());
        System.out.println(Integer.toBinaryString(5).length());
        System.out.println(Integer.toBinaryString(6).length());
        System.out.println(Integer.toBinaryString(7).length());
        System.out.println(Integer.toBinaryString(8).length());
        System.out.println(Integer.toBinaryString(9).length());
    }
}

Вывод:

1
1
2
2
3
3
3
3
4
4

Вот простой тест для скорости различных решений:

public class Tester 
{
    public static void main(final String[] argv) 
    {
        final int size;
        final long totalA;
        final long totalB;
        final long totalC;
        final long totalD;

        size = 100000000;

        totalA = test(new A(), size);
        totalB = test(new B(), size);
        totalC = test(new C(), size);
        totalD = test(new D(), size);

        System.out.println();
        System.out.println("Total D = " + totalD + " ms");
        System.out.println("Total B = " + totalB + " ms");
        System.out.println("Total C = " + totalC + " ms");
        System.out.println("Total A = " + totalA + " ms");

        System.out.println();
        System.out.println("Total B = " + (totalB / totalD) + " times slower");
        System.out.println("Total C = " + (totalC / totalD) + " times slower");
        System.out.println("Total A = " + (totalA / totalD) + " times slower");
    }

    private static long test(final Testable tester, 
                             final int      size)
    {
        final long start;
        final long end;
        final long total;

        start = System.nanoTime();
        tester.test(size);
        end   = System.nanoTime();
        total = end - start;

        return (total / 1000000);
    }

    private static interface Testable
    {
        void test(int size);
    }

    private static class A
        implements Testable
    {
        @Override
        public void test(final int size)
        {
            int value;

            value = 0;

            for(int i = 1; i < size; i++)
            {
                value += Integer.toBinaryString(i).length();
            }

            System.out.println("value = " + value);
        }    
    }

    private static class B
        implements Testable
    {
        @Override
        public void test(final int size)
        {
            int total;

            total = 0;

            for(int i = 1; i < size; i++)
            {
                int value = i;
                int count = 0;

                while (value > 0) 
                {
                    count++;
                    value >>= 1;
                }

                total += count;
            }

            System.out.println("total = " + total);
        }    
    }

    private static class C
        implements Testable
    {
        @Override
        public void test(final int size)
        {
            int total;
            final double log2;

            total = 0;
            log2  = Math.log(2);

            for(int i = 1; i < size; i++)
            {
                final double logX;
                final double temp;

                logX   = Math.log(i);
                temp   = logX / log2;                
                total += (int)Math.floor(temp) + 1;
            }

            System.out.println("total = " + total);
        }    
    }

    private static class D
        implements Testable
    {
        @Override
        public void test(final int size)
        {
            int total;

            total = 0;

            for(int i = 1; i < size; i++)
            {
                total += 32-Integer.numberOfLeadingZeros(i);
            }

            System.out.println("total = " + total);
        }    
    }
}

Вывод на моей машине:

value = -1729185023
total = -1729185023
total = -1729185023
total = -1729185023

Total D = 118 ms
Total B = 1722 ms
Total C = 4462 ms
Total A = 5704 ms

Total B = 14 times slower
Total C = 37 times slower
Total A = 48 times slower

Для тех из Вас жалующийся на скорость... https://en.wikipedia.org/wiki/Program_optimization#Quotes.

Запишите программу, чтобы быть читаемы первый, затем узнайте, где это медленно, затем сделайте его быстрее. Прежде и после оптимизации, тестируют изменение. Если изменение не было достаточно большим для расхода создания менее читаемого кода, не беспокоятся изменением.

Мой Java немного ржав, но агностический языком ответ (если бы существует функция "log2", и доступная функция "пола") был бы:

numberOfBits = floor(log2(decimalNumber))+1

Предположение, что "decimalNumber" больше, чем 0. Если это 0, Вам просто нужен 1 бит.

Ну, ответ довольно прост. Если у Вас есть международное значение:

int log2(int value) {
    return Integer.SIZE-Integer.numberOfLeadingZeros(value);
}

То же долгое время существует...

[Редактирование], Если бритье миллисекунд является проблемой здесь, Integer.numberOfLeadingZeros (интервал), довольно эффективно, но все еще делает 15 операций... При расширении разумного объема памяти (300 байтов, статичных), Вы могли побрить это к между 1 и 8 операциями, в зависимости от диапазона Ваших целых чисел.

Для неотрицательных значений вероятно, самый прямой ответ:

java.math.BigDecimal.valueOf(value).bitLength()

(Для отрицательных чисел это даст длину в битах меньше, чем абсолютное значение, а не бесконечность, которую Вы ожидали бы от дополнительной нотации two.)