Как получить 0-заполненное двоичное представление целого числа в java?

Ответ 1

Я думаю, что это субоптимальное решение, но вы могли бы сделать

String.format("%16s", Integer.toBinaryString(1)).replace(' ', '0')

Ответ 2

В java.util.Formatter нет двоичного преобразования, я бы посоветовал либо использовать String.replace, чтобы заменить символ пробела нулями, как в:

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0")

Или реализуйте свою собственную логику, чтобы преобразовать целые числа в двоичное представление с добавленным левым дополнением где-то вдоль строк, указанных в этом. Или, если вам действительно нужно передавать числа в формат, вы можете преобразовать свое двоичное представление в BigInteger, а затем отформатировать его с ведущими нулями, но это очень дорого во время выполнения, например:

String.format("%016d", new BigInteger(Integer.toBinaryString(1)))

Ответ 3

Вы можете использовать Apache Commons StringUtils. Он предлагает методы для заполнения строк:

StringUtils.leftPad(Integer.toBinaryString(1), 16, '0');

Ответ 4

Я пробовал всевозможные вызовы методов, которые я раньше не использовал, чтобы сделать эту работу, они работали с умеренным успехом, пока я не подумал о том, что так просто, что это может сработать, и это было!

Я уверен, что об этом думали раньше, не уверен, что это хорошо для длинной строки двоичных кодов, но отлично работает для строк 16 бит. Надеюсь, поможет!! (Обратите внимание, что вторая часть кода улучшена)

String binString = Integer.toBinaryString(256);
  while (binString.length() < 16) {    //pad with 16 0's
        binString = "0" + binString;
  }

Спасибо Will за то, что он помог улучшить этот ответ, чтобы он работал вне цикла. Это может быть немного неуклюжий, но он работает, пожалуйста, улучшите и прокомментируйте, если сможете...

binString = Integer.toBinaryString(256);
int length = 16 - binString.length();
char[] padArray = new char[length];
Arrays.fill(padArray, '0');
String padString = new String(padArray);
binString = padString + binString;

Ответ 5

Вот новый ответ для старого сообщения.

Чтобы поместить двоичное значение с ведущими нулями на определенную длину, попробуйте следующее:

Integer.toBinaryString( (1 << len) | val ).substring( 1 )

Если len = 4 и val = 1,

Integer.toBinaryString( (1 << len) | val )

возвращает строку "10001", затем

"10001".substring( 1 )

отбрасывает самый первый символ. Итак, мы получаем то, что хотим:

"0001"

Если val скорее всего будет отрицательным, попробуйте:

Integer.toBinaryString( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 )

Ответ 6

попробовать...

String.format("%016d\n", Integer.parseInt(Integer.toBinaryString(256)));

Я не думаю, что это "правильный" способ сделать это... но он работает:)

Ответ 7

Я не знаю "правильного" решения, но могу предложить вам быстрый патч.

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0");

Я только что попробовал и увидел, что он работает нормально.

Ответ 8

Простейшая версия идеи user3608934 "Это старый трюк, создайте строку с 16 0, затем добавьте обрезанную двоичную строку, которую вы получили":

private String toBinaryString32(int i) {
    String binaryWithOutLeading0 = Integer.toBinaryString(i);
    return "00000000000000000000000000000000"
            .substring(binaryWithOutLeading0.length())
            + binaryWithOutLeading0;
}

Ответ 9

Наивное решение, которое работает, будет

String temp = Integer.toBinaryString(5);
while (temp.length() < Integer.SIZE) temp = "0"+temp; //pad leading zeros
temp = temp.substring(Integer.SIZE - Short.SIZE); //remove excess

Еще один метод:

String temp = Integer.toBinaryString((m | 0x80000000));
temp = temp.substring(Integer.SIZE - Short.SIZE);

Это приведет к 16-битовой строке целого числа 5

Ответ 10

Это старый трюк, создайте строку с 16 0, затем добавьте выровненную двоичную строку, полученную из String.format( "% s", Integer.toBinaryString(1)) и используйте самые 16 символов, lopping с любого ведущего 0. Еще лучше сделайте функцию, которая позволяет указать, сколько времени требуется для бинарной строки. Конечно, есть, вероятно, и другие способы сделать это, включая библиотеки, но я добавляю этот пост, чтобы помочь другу:)

public class BinaryPrinter {

    public static void main(String[] args) {
        System.out.format("%d in binary is %s\n", 1, binaryString(1, 4));
        System.out.format("%d in binary is %s\n", 128, binaryString(128, 8));
        System.out.format("%d in binary is %s\n", 256, binaryString(256, 16));
    }

    public static String binaryString( final int number, final int binaryDigits ) {
        final String pattern = String.format( "%%0%dd", binaryDigits );
        final String padding = String.format( pattern, 0 );
        final String response = String.format( "%s%s", padding, Integer.toBinaryString(number) );

        System.out.format( "\npattern = '%s'\npadding = '%s'\nresponse = '%s'\n\n", pattern, padding, response );

        return response.substring( response.length() - binaryDigits );
    }
}

Ответ 11

Я бы написал свой собственный класс util с помощью метода, подобного ниже

public class NumberFormatUtils {

public static String longToBinString(long val) {
    char[] buffer = new char[64];
    Arrays.fill(buffer, '0');
    for (int i = 0; i < 64; ++i) {
        long mask = 1L << i;
        if ((val & mask) == mask) {
            buffer[63 - i] = '1';
        }
    }
    return new String(buffer);
}

public static void main(String... args) {
    long value = 0b0000000000000000000000000000000000000000000000000000000000000101L;
    System.out.println(value);
    System.out.println(Long.toBinaryString(value));
    System.out.println(NumberFormatUtils.longToBinString(value));
}

}

Вывод:

5
101
0000000000000000000000000000000000000000000000000000000000000101

Такой же подход может быть применен к любым интегральным типам. Обратите внимание на тип маски

long mask = 1L << i;

Ответ 12

Этот метод преобразует int в String, length = bits. Либо дополняется 0 или с наиболее значимыми битами, усеченными.

static String toBitString( int x, int bits ){
    String bitString = Integer.toBinaryString(x);
    int size = bitString.length();
    StringBuilder sb = new StringBuilder( bits );
    if( bits > size ){
        for( int i=0; i<bits-size; i++ )
            sb.append('0');
        sb.append( bitString );
    }else
        sb = sb.append( bitString.substring(size-bits, size) );

    return sb.toString();
}

Ответ 13

Вы можете использовать lib https://github.com/kssource/BitSequence. Он принимает число и возвращает строку, заполненную и/или сгруппированную.

String s = new BitSequence(2, 16).toBynaryString(ALIGN.RIGHT, GROUP.CONTINOUSLY));  
return  
0000000000000010  

another examples:

[10, -20, 30]->00001010 11101100 00011110
i=-10->00000000000000000000000000001010
bi=10->1010
sh=10->00 0000 0000 1010
l=10->00000001 010
by=-10->1010
i=-10->bc->11111111 11111111 11111111 11110110

Ответ 14

for(int i=0;i<n;i++)
{
  for(int j=str[i].length();j<4;j++)
  str[i]="0".concat(str[i]);
}

str[i].length() - длина номера, например, 2 в двоичном формате равна 01, длина 2 измените 4 на желаемую максимальную длину. Это можно оптимизировать для O (n). используя continue.

Ответ 15

//Ниже будем обрабатывать правильные размеры

public static String binaryString(int i) {
    return String.format("%" + Integer.SIZE + "s", Integer.toBinaryString(i)).replace(' ', '0');
}

public static String binaryString(long i) {
    return String.format("%" + Long.SIZE + "s", Long.toBinaryString(i)).replace(' ', '0');
}