convertir - binary to int java

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. Considerar:

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

¡Me encantan los bucles! ¡Hurra!

String myString = "1001001"; //73

Mientras bucle con acumulador, de izquierda a derecha (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 loops 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;

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

Necesitas especificar el radix . Hay una sobrecarga de Integer#parseInt() que te permite.

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

Answer 4

Si le preocupa el rendimiento, Integer.parseInt() y Math.pow() son demasiado caros. 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

Answer 5

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

Answer 6

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

funciona bien si se trata de números positivos, pero si necesita lidiar con números firmados es posible que deba firmar extender su cadena y luego convertir a un número

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!

Answer 7

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 8

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