(Java) Podaj liczbę bitów (długość) podczas konwersji liczby binarnej na ciąg?

Question

Próbuję zapisać numer jako ciąg binarny w tablicy, ale muszę określić, ile bitów do przechowywania go jako.

Na przykład, jeśli potrzebuję przechowywać 0 z dwoma bitami, potrzebuję ciągu "00". Lub 1010 z 6 bitami, więc "001010".

Czy ktoś może pomóc?

EDIT: Dzięki, chłopaki, ponieważ jestem marnością w matematyce/programowaniu w ogóle, poszedłem z najprostszym rozwiązaniem, które było Davidem. Coś jak:

binaryString.append(Integer.toBinaryString(binaryNumber)); 
for(int n=binaryString.length(); n<numberOfBits; n++) { 
         binaryString.insert(0, "0"); 
} 

Wydaje się działać prawidłowo, więc chyba jest to bardzo nieefektywne Pójdę z nim.

Answer 1

Zastosowanie Integer.toBinaryString() następnie sprawdzić długość ciągów i poprzedzić go tyle zer, ile potrzeba, aby pożądaną długość.

Answer 2

Zapomnij o domowych rozwiązaniach. Zamiast tego użyj standardu BigInteger. Możesz określić liczbę bitów, a następnie użyć metody toString (int radix), aby odzyskać to, czego potrzebujesz (zakładam, że potrzebujesz rady = 2).

EDIT: Zostawiłbym nieco kontroli do BigInteger. Obiekt będzie wewnętrznie zmieniać rozmiar bufora bitowego, aby dopasować nowy wymiar liczbowy. Ponadto za pomocą tego obiektu można wykonywać operacje arytmetyczne (nie trzeba implementować binarnych sumatorów/multiplikatorów itp.). Oto prosty przykład:

package test; 

import java.math.BigInteger; 

public class TestBigInteger 
{ 
    public static void main(String[] args) 
    { 
     String value = "1010"; 
     BigInteger bi = new BigInteger(value,2); 
     // Arithmetic operations 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.add(bi); // 10 + 10 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.multiply(bi); // 20 * 20 
     System.out.println("Output: " + bi.toString(2)); 

     /* 
     * Padded to the next event number of bits 
     */ 
     System.out.println("Padded Output: " + pad(bi.toString(2), bi.bitLength() + bi.bitLength() % 2)); 
    } 

    static String pad(String s, int numDigits) 
    { 
     StringBuffer sb = new StringBuffer(s); 
     int numZeros = numDigits - s.length(); 
     while(numZeros-- > 0) { 
      sb.insert(0, "0"); 
     } 
     return sb.toString(); 
    } 
} 

Answer 3

To jest częsty problem z zadaniami domowymi. Istnieje fajna pętla, którą możesz napisać, która obliczy najmniejszą moc 2> = twój numer docelowy n.

Ponieważ jest to potęga 2, logarytm podstawy 2 jest liczbą bitów. Ale biblioteka Java math oferuje tylko logarytm naturalny.

math.log(n)/math.log(2.0) 

to liczba bitów.

Answer 4

import java.util.BitSet; 

public class StringifyByte { 

    public static void main(String[] args) { 
     byte myByte = (byte) 0x00; 
     int length = 2; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 

     myByte = (byte) 0x0a; 
     length = 6; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 
    } 

    public static String stringifyByte(byte b, int len) { 
     StringBuffer bitStr = new StringBuffer(len); 
     BitSet bits = new BitSet(len); 
     for (int i = 0; i < len; i++) 
     { 
      bits.set (i, (b & 1) == 1); 
      if (bits.get(i)) bitStr.append("1"); else bitStr.append("0"); 
      b >>= 1; 
     } 
     return reverseIt(bitStr.toString()); 
    } 

    public static String reverseIt(String source) { 
     int i, len = source.length(); 
     StringBuffer dest = new StringBuffer(len); 

     for (i = (len - 1); i >= 0; i--) 
      dest.append(source.charAt(i)); 
     return dest.toString(); 
    } 
} 

wyjściowa:

myByte: 0x0 
bitString: 00 
myByte: 0x10 
bitString: 001010 

Answer 5

Oto proste rozwiązanie dla int wartości; powinno być oczywiste, jak rozszerzyć go na przykład do bajt itp

public static String bitString(int i, int len) { 
    len = Math.min(32, Math.max(len, 1)); 
    char[] cs = new char[len]; 
    for (int j = len - 1, b = 1; 0 <= j; --j, b <<= 1) { 
     cs[j] = ((i & b) == 0) ? '0' : '1'; 
    } 
    return new String(cs); 
} 

Tutaj jest wyjście z zestawem przykładowych przypadków testowych:

0 1        0        0 
    0 -1        0        0 
    0 40 00000000000000000000000000000000 00000000000000000000000000000000 
13 1        1        1 
13 2        01        01 
13 3        101        101 
13 4        1101        1101 
13 5       01101       01101 
-13 1        1        1 
-13 2        11        11 
-13 3        011        011 
-13 4        0011        0011 
-13 5       10011       10011 
-13 -1        1        1 
-13 40 11111111111111111111111111110011 11111111111111111111111111110011 

Oczywiście, jesteś na własną rękę, aby parametr długość wystarczająca do reprezentowania całą wartość .

Answer 6

jeszcze prostsze:

String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16)); 
String.format("%032", new BigInteger(binAddr)); 

Idea jest do analizowania ciąg z powrotem w postaci liczby dziesiętnej tymczasowo (jeden, który tak się składa wszystkim 1 i 0), a następnie użyć String.Format ().

pamiętać, że w zasadzie trzeba używać BigInteger, ponieważ ciągi binarne szybko przekroczenia zakresu liczb całkowitych i długich powstałego w NumberFormatExceptions jeśli spróbujesz użyć Integer.fromString() lub Long.fromString().

Answer 7

Spróbuj tego:

String binaryString = String.format("%"+Integer.toString(size)+"s",Integer.toBinaryString(19)).replace(" ","0"); 

gdzie wielkość może być dowolna liczba użytkownik chce

Answer 8

Więc zamiast 8 można napisać żądaną długość i będzie dołączać zera odpowiednio. Jeżeli długość wymienionej liczby całkowitej przekracza liczbę wymienionych to nie doda żadnych zer

String.format("%08d",1111);

wyjściowa: 00001111

String.format("%02d",1111); 

wyjściowa: 1111