Cómo convertir una cadena binaria a un entero de base 10 en Java

Question

Tengo una matriz de cadenas que representan números binarios (sin ceros a la izquierda) que quiero convertir a sus 10 números base correspondientes. Considere:

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

¿Cuál es la mejor manera de proceder? He estado explorando java.lang.number. * Sin encontrar un método de conversión directa. Integer.parseInt(b) arroja un número entero IGUAL a la Cadena ... por ejemplo, 1001 se convierte en 1,001 en lugar de 9 ... y no parece incluir un parámetro para una base de salida. toBinaryString hace la conversión en la dirección incorrecta. Sospecho que tendré que hacer una conversión de varios pasos, pero no puedo encontrar la combinación correcta de métodos o subclases. Tampoco estoy seguro de hasta qué punto los ceros a la izquierda o la falta de ellos serán un problema. ¿Alguien tiene alguna buena dirección para señalarme?

Answer 1

Necesita specify the radix. Hay una sobrecarga de Integer#parseInt() que le permite.

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

Answer 2

Esto podría funcionar:

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

Answer 3

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

Creo que estoy aún más aburrido! La respuesta de Hassan modificada para funcionar correctamente.

Answer 4

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

funciona bien si se trata de números positivos, pero si tiene que tratar con números con signo puede que tenga que firmar ampliar su cadena a continuación, convertir a 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 

Espero que ayude !

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

Answer 6

I love loops! ¡Hurra!

String myString = "1001001"; //73 

While con acumulador, de izquierda a derecha (l no cambia):

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

De derecha a izquierda con 2 vars bucle, inspirado por Convert boolean to int in Java (absolutamente 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; 

Una implementación algo más razonable:

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

Una versión legible: p

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

Answer 7

versión fija del Integer.parseInt (texto) de Java para trabajar con números negativos:

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

Answer 8

Si está preocupado por el rendimiento, y Integer.parseInt()Math.pow() son muy caro.Puede utilizar la manipulación poco para hacer la misma cosa dos veces más rápido (basado en mi experiencia):

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

Dónde

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

Salida:

Input Number: 87 toBinary 1010111 
Output Number: 87 toBinary 1010111