Como converter uma String Binária para um inteiro de base 10 em Java

Eu tenho uma matriz de seqüências de caracteres que representam números binários (sem zeros à esquerda) que eu quero converter em seus 10 números de base correspondentes. Considerar:

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

Qual é a melhor maneira de prosseguir? Eu tenho explorado java.lang.number. * Sem encontrar um método de conversão direta. Integer.parseInt(b) produz um inteiro Integer.parseInt(b) a String … por exemplo, 1001 se torna 1.001 em vez de 9 … e não parece include um parâmetro para uma base de saída. toBinaryString faz a conversão na direção errada. Eu suspeito que precisarei fazer uma conversão em várias etapas, mas não consigo encontrar a combinação certa de methods ou subclasss. Eu também não tenho certeza até que ponto os zeros iniciais ou a falta deles serão um problema. Alguém tem boas indicações para me apontar?

Você precisa especificar o radical . Há uma sobrecarga de Integer#parseInt() que permite a você.

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

Isso pode 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 muito bem se você está lidando com números positivos, mas se você precisa lidar com números assinados você pode precisar assinar estender sua seqüência de converter em um 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 isso ajude!

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

Eu acho que estou ainda mais entediado! Modificado a resposta de Hassan para funcionar corretamente.

Versão corrigida do Integer.parseInt (texto) do java para trabalhar com 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; } 

Se você está preocupado com o desempenho, Integer.parseInt() e Math.pow() são muito caros. Você pode usar a manipulação de bits para fazer a mesma coisa duas vezes mais rápido (com base na minha experiência):

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

Onde

 int binaryStringToDecimal(String biString){ int n = biString.length(); int decimal = 0; for (int d = 0; d < n; d++){ // append a bit=0 (ie 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; // eg dec = 110 | (00)1 = 111 } } return decimal; } 

Saída:

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

Eu amo loops! Yay!

 String myString = "1001001"; //73 

Enquanto loop com acumulador, da esquerda para a direita ( l não muda):

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

Da direita para a esquerda com 2 loop vars, inspirado em Convert boolean to int em Java (absolutamente horrível):

 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; 

Uma implementação um pouco mais razoável:

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

Uma versão legível: p

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