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

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

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

¿Cuál es la mejor forma de proceder? He estado explorando java.lang.number. * Sin encontrar un método de conversión directo. Integer.parseInt(b)produce 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. toBinaryStringhace la conversión en la dirección equivocada. Sospecho que tendré que hacer una conversión de varios pasos, pero parece que no puedo encontrar la combinación correcta de métodos o subclases. Tampoco estoy seguro de hasta qué punto los ceros iniciales o la falta de ellos serán un problema. ¿Alguien tiene buenas direcciones para señalarme?

Usted necesita especificar la raíz . Hay una sobrecarga Integer#parseInt()que te permite.

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

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

funciona bien si se trata de números positivos, pero si necesita tratar con números con signo, es posible que deba firmar, extender su cadena y luego 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 eso ayude!

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

¡Creo que estoy aún más aburrido! Se modificó la respuesta de Hassan para que funcione correctamente.

Para mí, obtuve NumberFormatException al tratar de lidiar con los números negativos. Usé lo siguiente para los números negativos y positivos.

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

Output : -9

Versión fija de 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;
}

¡Amo los bucles! ¡Hurra!

String myString = "1001001"; //73

Mientras que el bucle con acumulador, de izquierda a derecha ( lno 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 de bucle, inspirado en Convert boolean to int en 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;

Si le preocupa el rendimiento Integer.parseInt()y Math.pow()es demasiado caro. Puede usar la manipulación de bits para hacer lo mismo dos veces más rápido (según 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