(Java) angeben Anzahl von Bits (Länge), wenn Binärzahl zu bespannen Umwandeln?

Question

Ich versuche, eine Zahl als Binär-String in einem Array zu speichern, aber ich brauche, um festzulegen, wie viele Bits zu speichern es als.

Zum Beispiel, wenn ich 0 mit zwei Bits speichern müssen brauche ich eine Zeichenfolge „00“. Oder 1010 mit 6 Bits so "001010".

Kann mir jemand helfen?

EDIT: Danke Jungs, wie ich Müll in Mathe / Programmierung im Allgemeinen bin habe ich mit der einfachsten Lösung gegangen, die David. So etwas wie:

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

Es scheint gut zu funktionieren, es sei denn, es ist sehr ineffizient, das ich mit ihm gehen werde.

Answer 1

Verwenden Integer.toBinaryString() dann die String-Länge überprüfen und mit so vielen Nullen voranstellen, wie Sie Ihre gewünschte Länge vornehmen müssen.

Answer 2

Vergessen Sie hausgemachte Lösungen. Verwenden Sie Standard- BigInteger statt. Sie können Anzahl der Bits angeben und verwenden Sie dann toString (int radix) Methode zu erholen, was Sie brauchen (ich nehme an, Sie brauchen radix = 2).

EDIT: Ich würde wenig Kontrolle BigInteger verlassen. Das Objekt wird intern seine Bit-Puffer der Größe die neue Nummer Dimension passen. Außerdem können arithmetische Operationen mit Hilfe dieses Objekt durchgeführt werden (Sie müssen nicht binäre Addierer / Multiplizierer usw. implementieren). Hier ist ein einfaches Beispiel:

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

Dies ist ein häufiges Problem Hausaufgaben. Es ist eine coole Schleife, die Sie schreiben können, dass die kleinste Potenz von 2> = Ihrer Zielnummer berechnen n .

Da es sich um eine Potenz von 2 ist, der Logarithmus zur Basis 2 ist die Anzahl der Bits. Aber die Java math Bibliothek bietet neben natürliche Logarithmus.

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

ist die Anzahl der Bits.

Answer 4

Noch einfacher:

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

Die Idee hier ist die Zeichenfolge wieder als Dezimalzahl vorübergehend zu analysieren (eine, die gerade passiert, so daß ich aus allen 1 und 0) und verwenden Sie dann String.format ().

Beachten Sie, dass Sie im Grunde BigInteger verwenden, weil Binärketten schnell Integer und langen Überlauf in NumberFormatExceptions ergibt, wenn Sie versuchen, Integer.fromString() oder Long.fromString() zu verwenden.

Answer 5

Versuchen Sie folgendes:

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

, wo Größe kann eine beliebige Zahl der Benutzer

Answer 6

Hier ist eine einfache Lösung für int Werte; es sollte klar sein, wie es zu erweitern, um z.B. Byte, etc.

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

Hier

ist der Ausgang aus einem Satz von Beispieltestfällen:

  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

Natürlich sind Sie auf eigene Faust die Längenparameter zu machen ausreichen, um den gesamten Wert darzustellen.

Answer 7

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

Ausgabe:

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

Answer 8

Also hier statt 8 können Sie Ihre gewünschte Länge schreiben, und es wird Nullen entsprechend anhängen. Wenn die Länge der genannten ganzen Zahl übersteigt die der Zahl erwähnt, dann wird es keine Nullen anhängen

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

  

Ausgabe: 00001111

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

  

Ausgabe 1111