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

Question

Ho una matrice di stringhe che rappresentano numeri binari (senza zeri iniziali) che voglio convertire nei 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 esegue 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?

Answer 1

È necessario specify the radix. C'è un sovraccarico di Integer#parseInt() che ti permette di.

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

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

Answer 3

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

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

Answer 4

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

funziona bene se avete a che fare con i numeri positivi, ma se avete bisogno di trattare con i numeri con segno potrebbe essere necessario firmare estendere la stringa poi convertire in 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 

Mi auguro che aiuta !

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

Answer 6

I love loops! Sìì!

String myString = "1001001"; //73 

While con accumulatore, da sinistra a destra (l 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 vars ciclo, ispirato Convert boolean to 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; 

Answer 7

versione fissa di java Integer.parseInt (testo) per lavorare con i 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; 
} 

Answer 8

Se siete preoccupati per le prestazioni, Integer.parseInt() e Math.pow() sono troppo caro.È possibile utilizzare la manipolazione bit per fare la stessa cosa due volte più veloce (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 (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; 
} 

uscita:

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