web-dev-qa-db-fra.com

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) que je veux convertir en 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é le fichier Java.lang.number. * Sans trouver de méthode de conversion directe. Integer.parseInt(b) renvoie un entier EQUAL dans 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. toBinaryString effectue la conversion dans le mauvais sens. Je suppose que je devrai effectuer 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 la mesure dans laquelle des zéros non significatifs constitueront un problème. Quelqu'un at-il une bonne direction pour me diriger?

javastringbinaryradix
77
dwwilson66

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

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

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;
}
16
Hassan
int foo = Integer.parseInt("1001", 2);

fonctionne très bien si vous avez affaire à des nombres positifs, mais si vous devez gérer des nombres signés, vous devrez peut-être étendre votre chaîne, puis convertir en un

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 ça aide!

6
txcotrader
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;
}
5
Rudy Duran
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! La réponse de Hassan a été modifiée pour fonctionner correctement.

2
ModernIncantations

Si vous êtes préoccupé par les performances, Integer.parseInt() et Math.pow() sont trop chers. Vous pouvez utiliser la manipulation de bits pour faire la même chose deux fois plus vite (selon 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;
}

Sortie:

 Input Number: 87 toBinary 1010111
Output Number: 87 toBinary 1010111
0
anask

Version fixe 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
skyrosbit

Pour moi, j'ai eu 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
Zeus