Jak uzyskać 0-padded reprezentacji binarnej liczby całkowitej w java?

Question

na przykład dla 1, 2, 128, 256 wyjście może być (16 cyfr):

0000000000000001 
0000000000000010 
0000000010000000 
0000000100000000 

Próbowałem

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

stawia spacje na lewym padding:

`    1' 

Jak umieścić 0 s do wyściółki. Nie mogłem go znaleźć w Formatter. Czy jest inny sposób na zrobienie tego?

Z góry dziękuję.

P.S. this post opisuje, jak formatować liczby całkowite z lewym wypełnieniem 0, ale nie jest to reprezentacja binarna.

Answer 1

myślę, że to jest panującymi rozwiązanie, ale można zrobić

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

Answer 2

try ...

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

nie sądzę, to jest "poprawny" sposób to zrobić ... ale działa :)

Answer 3

Nie ma konwersji binarnej wbudowanej w java.util.Formatter, radziłbym albo użyć String.replace, aby zamienić znak spacji na zero, jak w:

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

Można też zaimplementować własną logikę, aby przekonwertować liczby całkowite na reprezentację binarną z dodanym lewym dopełnieniem gdzieś wzdłuż linii podanych w this, tak. Lub jeśli naprawdę trzeba przekazać numery do formatu można przekonwertować reprezentację binarną do BigInteger a następnie sformatować że z zerem na początku, ale jest to bardzo kosztowne w czasie wykonywania, jak w:

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

Answer 4

nie wiem "właściwe" rozwiązanie, ale mogę zaproponować ci szybką łatkę.

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

Po prostu wypróbowałem i zobaczyłem, że działa dobrze.

Answer 5

Próbowałem różnego rodzaju wywołań metod, których tak naprawdę nie używałem wcześniej, aby wykonać tę pracę, pracowały z umiarkowanym powodzeniem, dopóki nie pomyślałem o czymś, co jest tak proste, że może po prostu zadziała, i tak było!

Jestem pewien, że już wcześniej o tym pomyślałem, nie jestem pewien, czy to jest dobre dla długich ciągów kodów binarnych, ale działa dobrze dla ciągów 16 bitowych. Mam nadzieję, że to pomoże!! (Uwaga: poprawiono drugi fragment kodu)

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

Podziękowania dla Willa za pomoc w ulepszeniu tej odpowiedzi, aby działała bez problemów. To może trochę niezdarny, ale to działa, proszę poprawić i komentarz z powrotem, jeśli możesz ....

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; 

Answer 6

Można użyć Apache Commons StringUtils.Oferuje on metody ciągów padding:

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

Answer 7

To jest stara sztuczka, utworzyć ciąg z 16 0 ówczesny dołączyć przyciętego binarny ciąg uzyskanego z String.Format („% S”, Integer.toBinaryString (1)) i użyj 16 najbardziej prawych znaków, odrywając wszystkie wiodące zera. Co więcej, należy utworzyć funkcję, która pozwala określić długość żądanego ciągu binarnego. Oczywiście istnieją prawdopodobnie bazillion inne sposoby, aby to osiągnąć w tym biblioteki, ale Dodaję ten post pomóc znajomym :)

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

Answer 8

Prostsza wersja pomysłu user3608934 za „To jest stara sztuczka, tworzyć ciąg znaków 16 0, a następnie dołączony przycięty łańcuch dwójkowy, który masz ":

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

Answer 9

Oto nowa odpowiedź na stary post.

pad wartość binarna z wiodącymi zerami do określonej długości, spróbuj tego:

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

Jeśli len = 4 i val = 1,

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

zwraca łańcuch "10001", następnie

"10001".substring(1) 

odrzuca pierwszą postać. Tak więc otrzymujemy to, co chcemy:

"0001" 

Jeśli val może być negatywna, raczej spróbuj:

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

Answer 10

chciałbym napisać własną klasę util z metody jak poniżej

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

}

Wyjście:

 
5 
101 
0000000000000000000000000000000000000000000000000000000000000101 

To samo podejście można zastosować do integralnych typów. Należy zwrócić uwagę na rodzaj maski

long mask = 1L << i;

Answer 11

Sposób ten przekształca int do łańcucha, długość = bitów. Albo wypełniony zerami, albo najbardziej znaczącymi bitami obciętymi.

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

Answer 12

Naiwny rozwiązanie, które działa byłoby

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 

Inną metodą byłoby

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

To będzie produkować ciąg 16 bitowej liczby całkowitej 5

Answer 13

Można użyj lib https://github.com/kssource/BitSequence. Akceptuje numer i zwraca ciąg bajta, dopełniony i/lub zgrupowany.

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 

Answer 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() ma długość liczbą mówią 2 w binarnym 01, który jest zmiana długości 2 4 do żądanej długości maksymalnej liczby. Można to zoptymalizować do O (n). za pomocą polecenia Kontynuuj.