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

108

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?

dwwilson66
fuente

Respuestas:

263

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

int foo = Integer.parseInt("1001", 2);
Matt Ball
fuente
1
Perfección. Me perdí por completo la segunda línea en la documentación parseInt que permite el radix. Funciona como un sueño.
dwwilson66
1
¿Esto también funciona con ceros a la izquierda? Solo confirmando, aunque no veo ninguna razón por la que no.
Siddhartha
@NagabhushanBaddi ejemplo? ¿Está pasando una representación en complemento a dos?
Matt Ball
18

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;
}
Hassan
fuente
Supongo que es algo innecesario. Eso es lo que pasa cuando tienes un poco de tiempo entre clases.
Hassan
6
este es útil para mí porque tengo que hacer un proyecto escolar con conversiones sin usar las que ya tiene java
bucksnort2
¿Alguien probó esto antes? aquí el número de longitud menos el índice más 1 se ha multiplicado por 2, si no me equivoco en bynary, empiece con 1 y multiplique ese valor por 2, luego tome el resultado y multiplique ese uno por 2 que será su 3 lugar y así en
Christopher Cabezudo Rodriguez
(EL CUADRO DE COMENTARIOS NO ES BUENO PARA SNIPPETS) Aquí el Código que estoy usando base en el suyo (estaba perdido y uso el suyo como plantilla) public static int binaryToInteger (String binary) {char [] numbers = binary.ToCharArray (); int resultado = 0; int posValue = 1; for (int i = números.Longitud - 1; i> = 0; i--) {if (números [i] == '1') {resultado + = posValue; } posValue * = 2; } devolver resultado; }
Christopher Cabezudo Rodríguez
1
Este fragmento de código no funciona. forbucle y el cálculo de la nueva resultvariable no es correcto.
trylimits
8
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!

txcotrader
fuente
1
Necesitaba -1 convertido de binario a decimal, hice esto. System.out.println ((int) Long.parseLong ("111111111111111111111111111111", 2));
Zeus
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;
}
Rudy Duran
fuente
2
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.

Encantamientos Modernos
fuente
1

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
Zeus
fuente
0

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;
}
skyrosbit
fuente
0

¡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;
bjb568
fuente
0

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
una pregunta
fuente