(Java) Spécifiez le nombre de bits (longueur) lors de la conversion d'un nombre binaire en chaîne?

Question

J'essaie de stocker un nombre sous forme de chaîne binaire dans un tableau, mais je dois spécifier le nombre de bits sous lequel le stocker.

Par exemple, si j'ai besoin de stocker 0 avec deux bits, j'ai besoin d'une chaîne "00". Ou 1010 avec 6 bits pour "001010".

Quelqu'un peut-il aider?

EDIT: Merci les gars, comme je suis nul en mathématiques / programmation en général, je suis allé avec la solution la plus simple qui était celle de David. Quelque chose comme:

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

Cela semble bien fonctionner, donc à moins que ce ne soit très inefficace, j'y vais.

Answer 1

Utilisez Integer.toBinaryString () , puis vérifiez la longueur de la chaîne et ajoutez-y autant de zéros que nécessaire pour définir la longueur souhaitée.

Answer 2

Oubliez les solutions maison. Utilisez plutôt la norme BigInteger . Vous pouvez spécifier le nombre de bits, puis utiliser la méthode toString (int radix) pour récupérer ce dont vous avez besoin (je suppose que vous avez besoin de radix = 2).

EDIT: je laisserais le contrôle de bit à BigInteger. L'objet redimensionnera en interne son tampon de bits pour l'adapter à la nouvelle dimension numérique. De plus, les opérations arithmétiques peuvent être effectuées à l'aide de cet objet (vous n'avez pas à implémenter d'additionneurs / multiplicateurs binaires, etc.). Voici un exemple de base:

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

Ceci est un problème de devoirs commun. Vous pouvez écrire une boucle cool qui calculera la plus petite puissance de 2 > = votre nombre cible n .

Puisqu'il s'agit d'une puissance de 2, le logarithme en base 2 correspond au nombre de bits. Mais la bibliothèque math de Java ne propose que le logarithme naturel.

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

est le nombre de bits.

Answer 4

Encore plus simple:

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

L’idée ici est d’analyser temporairement la chaîne en tant que nombre décimal (celui qui se compose des 1 et des 0), puis d’utiliser String.format ().

Notez que vous devez essentiellement utiliser BigInteger, car les chaînes binaires débordent rapidement Integer et Long, ce qui génère des exceptions NumberFormatExceptions si vous essayez d'utiliser Integer.fromString () ou Long.fromString () .

Answer 5

Essayez ceci:

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

où taille peut être n'importe quel nombre voulu par l'utilisateur

Answer 6

Voici une solution simple pour les valeurs int ; il devrait être évident de savoir comment l’étendre, par exemple. octet, 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);
}

Voici la sortie d'un ensemble d'exemples de tests:

  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

Bien sûr, vous êtes seul pour rendre le paramètre de longueur adéquat pour représenter la valeur entière.

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

Sortie:

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

Answer 8

Donc ici, au lieu de 8, vous pouvez écrire la longueur souhaitée et ajouter des zéros en conséquence. Si la longueur de votre entier mentionné dépasse celle du nombre mentionné, il n’ajoutera aucun zéros

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

  

Sortie: 00001111

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

  

sortie: 1111