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

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

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

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

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

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

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

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

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

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;

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

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

вот новый ответ на старый пост.

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

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 )

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

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

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

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

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

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

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

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

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

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

Это старый трюк, создайте строку с 16 0, затем добавьте обрезанную двоичную строку, которую вы получили из строки.формат ("%s", целое число.toBinaryString(1)), а правый-всего 16 символов, срубая 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 );
    }
}

Я бы написал свой собственный класс 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;

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

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();
}

вы можете использовать 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

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). с помощью продолжить.

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

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');
}