Comment convertir une chaîne binaire en un entier de base 10 en Java


108

J'ai un tableau de chaînes qui représentent des nombres binaires (sans zéros non significatifs) que je veux convertir en leurs nombres de base 10 correspondants. Considérer:

binary 1011 becomes integer 11
binary 1001 becomes integer 9
binary   11 becomes integer 3   etc. 

Quelle est la meilleure façon de procéder? J'ai exploré java.lang.number. * Sans trouver de méthode de conversion directe. Integer.parseInt(b)donne un entier EQUAL à la chaîne ... par exemple, 1001 devient 1 001 au lieu de 9 ... et ne semble pas inclure de paramètre pour une base de sortie. toBinaryStringfait la conversion dans le mauvais sens. Je soupçonne que j'aurai besoin de faire une conversion en plusieurs étapes, mais je n'arrive pas à trouver la bonne combinaison de méthodes ou de sous-classes. Je ne suis pas non plus sûr de savoir dans quelle mesure les zéros non significatifs ou leur absence seront un problème. Quelqu'un a-t-il de bonnes directions pour me diriger?



Réponses:


264

Vous devez spécifier la base . Il y a une surcharge Integer#parseInt()qui vous le permet.

int foo = Integer.parseInt("1001", 2);

1
La perfection. J'ai complètement manqué la deuxième ligne de la documentation parseInt qui permet le radix. Fonctionne comme un rêve.
dwwilson66

1
Cela fonctionne-t-il aussi avec les zéros non significatifs? Je confirme simplement, même si je ne vois aucune raison de le faire.
Siddhartha

Exemple @NagabhushanBaddi? Passez-vous une représentation de complément à deux?
Matt Ball

18

Cela pourrait fonctionner:

public int binaryToInteger(String binary) {
    char[] numbers = binary.toCharArray();
    int result = 0;
    for(int i=numbers.length - 1; i>=0; i--)
        if(numbers[i]=='1')
            result += Math.pow(2, (numbers.length-i - 1));
    return result;
}

Je suppose que c'est un peu inutile. C'est ce qui se passe lorsque vous avez un peu de temps entre les cours.
Hassan

6
celui-ci est utile pour moi car je dois faire un projet scolaire avec des conversions sans utiliser ceux que java a déjà
bucksnort2

Quelqu'un a-t-il déjà testé cela? ici nombre.longueur moins l'indice plus 1 a été multiplié par 2, si je ne me trompe pas en bynary vous commencez par 1 et multipliez cette valeur par 2 puis prenez le résultat et multipliez celui par 2 qui sera votre 3 place et ainsi sur
Christopher Cabezudo Rodriguez

(COMMENT BOX N'EST PAS BON POUR LES SNIPPETS) Voici le code que j'utilise base dans le vôtre (j'ai été perdu et j'utilise le vôtre comme modèle) public static int binaryToInteger (String binary) {char [] numbers = binary.ToCharArray (); résultat int = 0; int posValue = 1; for (int i = nombres.Longueur - 1; i> = 0; i--) {if (nombres [i] == '1') {result + = posValue; } posValue * = 2; } retourne le résultat; }
Christopher Cabezudo Rodriguez

1
Cet extrait de code ne fonctionne pas. forboucle et le calcul de la nouvelle resultvariable n'est pas correct.
trylimits du

8
int foo = Integer.parseInt("1001", 2);

fonctionne très bien si vous avez affaire à des nombres positifs, mais si vous avez besoin de traiter des nombres signés, vous devrez peut-être signer étendre votre chaîne, puis convertir en un Int

public class bit_fun {
    public static void main(String[] args) {
        int x= (int)Long.parseLong("FFFFFFFF", 16);
        System.out.println("x =" +x);       

        System.out.println(signExtend("1"));
        x= (int)Long.parseLong(signExtend("1"), 2);
        System.out.println("x =" +x);

        System.out.println(signExtend("0"));
        x= (int)Long.parseLong(signExtend("0"), 2);
        System.out.println("x =" +x);

        System.out.println(signExtend("1000"));
        x= (int)Long.parseLong(signExtend("1000"), 2);
        System.out.println("x =" +x);

        System.out.println(signExtend("01000"));
        x= (int)Long.parseLong(signExtend("01000"), 2);
        System.out.println("x =" +x);
    }

    private static String signExtend(String str){
        //TODO add bounds checking
        int n=32-str.length();
        char[] sign_ext = new char[n];
        Arrays.fill(sign_ext, str.charAt(0));

        return new String(sign_ext)+str;
    }
}

output:
x =-1
11111111111111111111111111111111
x =-1
00000000000000000000000000000000
x =0
11111111111111111111111111111000
x =-8
00000000000000000000000000001000
x =8 

J'espère que cela aide!


1
J'avais besoin de -1 converti de binaire en décimal, je l'ai fait. System.out.println ((int) Long.parseLong ("111111111111111111111111111111", 2));
Zeus

5
static int binaryToInt (String binary){
    char []cA = binary.toCharArray();
    int result = 0;
    for (int i = cA.length-1;i>=0;i--){
        //111 , length = 3, i = 2, 2^(3-3) + 2^(3-2)
        //                    0           1  
        if(cA[i]=='1') result+=Math.pow(2, cA.length-i-1);
    }
    return result;
}

2
public Integer binaryToInteger(String binary){
    char[] numbers = binary.toCharArray();
    Integer result = 0;
    int count = 0;
    for(int i=numbers.length-1;i>=0;i--){
         if(numbers[i]=='1')result+=(int)Math.pow(2, count);
         count++;
    }
    return result;
}

Je suppose que je m'ennuie encore plus! Modification de la réponse de Hassan pour qu'elle fonctionne correctement.


1

Pour moi, j'ai obtenu NumberFormatException en essayant de gérer les nombres négatifs. J'ai utilisé ce qui suit pour les nombres négatifs et positifs.

System.out.println(Integer.parseUnsignedInt("11111111111111111111111111110111", 2));      

Output : -9

0

Correction de la version de Integer.parseInt (texte) de Java pour travailler avec des nombres négatifs:

public static int parseInt(String binary) {
    if (binary.length() < Integer.SIZE) return Integer.parseInt(binary, 2);

    int result = 0;
    byte[] bytes = binary.getBytes();

    for (int i = 0; i < bytes.length; i++) {
        if (bytes[i] == 49) {
            result = result | (1 << (bytes.length - 1 - i));
        }
    }

    return result;
}

0

J'adore les boucles! Yay!

String myString = "1001001"; //73

En boucle avec accumulateur, de gauche à droite ( lne change pas):

int n = 0,
    j = -1,
    l = myString.length();
while (++j < l) n = (n << 1) + (myString.charAt(j) == '0' ? 0 : 1);
return n;

De droite à gauche avec 2 variables de boucle, inspirées de Convert boolean to int en Java (absolument horrible):

int n = 0,
    j = myString.length,
    i = 1;
while (j-- != 0) n -= (i = i << 1) * new Boolean(myString.charAt(j) == '0').compareTo(true);
return n >> 1;

Une implémentation un peu plus raisonnable:

int n = 0,
    j = myString.length(),
    i = 1;
while (j-- != 0) n += (i = i << 1) * (myString.charAt(j) == '0' ? 0 : 1);
return n >> 1;

Une version lisible: p

int n = 0;
for (int j = 0; j < myString.length(); j++) {
    n *= 2;
    n += myString.charAt(j) == '0' ? 0 : 1;
}
return n;

0

Si vous êtes préoccupé par les performances Integer.parseInt()et que vous Math.pow()êtes trop cher. Vous pouvez utiliser la manipulation de bits pour faire la même chose deux fois plus vite (d'après mon expérience):

final int num = 87;
String biStr = Integer.toBinaryString(num);

System.out.println(" Input Number: " + num + " toBinary "+ biStr);
int dec = binaryStringToDecimal(biStr);
System.out.println("Output Number: " + dec + " toBinary "+Integer.toBinaryString(dec));

int binaryStringToDecimal(String biString){
  int n = biString.length();      
  int decimal = 0;
  for (int d = 0; d < n; d++){
    // append a bit=0 (i.e. shift left) 
    decimal = decimal << 1;

    // if biStr[d] is 1, flip last added bit=0 to 1 
    if (biString.charAt(d) == '1'){
      decimal = decimal | 1; // e.g. dec = 110 | (00)1 = 111
    }
  }
  return decimal;
}

Production:

 Input Number: 87 toBinary 1010111
Output Number: 87 toBinary 1010111
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.