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

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?

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

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

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

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!

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

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.

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

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

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;

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

Où

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