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

Ho un array di stringhe che rappresentano i numeri binari (senza zeri iniziali) che voglio convertire nei loro numeri di base 10 corrispondenti. Tener conto di:

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

Qual è il modo migliore per procedere? Ho esplorato java.lang.number. * Senza trovare un metodo di conversione diretta. Integer.parseInt(b)restituisce un numero intero UGUALE alla stringa ... ad esempio, 1001 diventa 1,001 invece di 9 ... e non sembra includere un parametro per una base di output. toBinaryStringfa la conversione nella direzione sbagliata. Sospetto di dover eseguire una conversione in 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 buone indicazioni per indicarmi?

Devi specificare il file radix . C'è un sovraccarico Integer#parseInt()che ti permette di farlo.

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 trattare con numeri firmati potresti aver bisogno di firmare estendi la tua stringa quindi convertila 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 

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! Risposta di Hassan modificata per funzionare correttamente.

Per me ho ricevuto NumberFormatException quando ho provato a gestire i numeri negativi. Ho usato quanto segue per i numeri negativi e positivi.

System.out.println(Integer.parseUnsignedInt("11111111111111111111111111110111", 2));      

Output : -9

Corretta la versione 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;
}

Adoro i loop! Sìì!

String myString = "1001001"; //73

While loop con accumulatore, da sinistra a destra ( lnon 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 variabili di ciclo, ispirate a 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;

Se sei preoccupato per le prestazioni Integer.parseInt()e Math.pow()sei troppo costoso. Puoi usare la manipolazione dei 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 (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;
}

Produzione:

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