Come convertire una stringa binaria in un numero intero 10 di base in Java

Ho una serie di stringhe che rappresentano numeri binari (senza zeri iniziali) che voglio convertire ai corrispondenti numeri di base 10. Prendere in considerazione:

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

Qual è il modo migliore di procedere? Ho esplorato java.lang.number. * Senza trovare un metodo di conversione diretto. Integer.parseInt(b) restituisce un intero EQUAL alla stringa … ad esempio, 1001 diventa 1,001 anziché 9 … e non sembra includere un parametro per una base di output. toBinaryString fa la conversione nella direzione sbagliata. Sospetto che avrò bisogno di fare una conversione a più fasi, ma non riesco a trovare la giusta combinazione di metodi o sottoclassi. Inoltre, non sono sicuro della misura in cui gli zeri iniziali o la loro mancanza saranno un problema. Qualcuno ha delle buone indicazioni per indicarmi?

Devi specificare la radice . C’è un sovraccarico di Integer#parseInt() che ti permette di.

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

Questo potrebbe funzionare:

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

funziona bene se hai a che fare con numeri positivi ma se hai bisogno di gestire i numeri firmati potresti dover firmare estendere la stringa e poi convertirla in 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 

Spero che aiuti!

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

Immagino di essere ancora più annoiato! La risposta di Hassan modificata per funzionare correttamente.

Versione fissa di Integer.parseInt (testo) di java per lavorare con numeri negativi:

 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 sei preoccupato per le prestazioni, Integer.parseInt() e Math.pow() sono troppo costosi. Puoi usare la manipolazione di bit per fare la stessa cosa due volte più velocemente (in base alla mia esperienza):

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

Dove

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

Produzione:

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

Adoro i loop! Sìì!

 String myString = "1001001"; //73 

Mentre il ciclo con accumulatore, da sinistra a destra (non cambia):

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

Da destra a sinistra con 2 loop vars, ispirato a Converti booleano a int in Java (assolutamente orribile):

 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; 

Un'implementazione un po 'più ragionevole:

 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 versione leggibile: p

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