So konvertieren Sie eine Binärzeichenfolge in eine Ganzzahl der Basis 10 in Java

Ich habe eine Reihe von Zeichenfolgen, die Binärzahlen (ohne führende Nullen) darstellen, die ich in die entsprechenden Basis-10-Zahlen konvertieren möchte. Erwägen:

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

Wie gehe ich am besten vor? Ich habe java.lang.number. * Untersucht, ohne eine direkte Konvertierungsmethode gefunden zu haben. Integer.parseInt(b)ergibt eine ganze Zahl EQUAL zum String ... zB wird 1001 zu 1.001 statt 9 ... und scheint keinen Parameter für eine Ausgabebasis zu enthalten. toBinaryStringmacht die Umwandlung die falsche Richtung. Ich vermute, dass ich eine mehrstufige Konvertierung durchführen muss, kann aber anscheinend nicht die richtige Kombination von Methoden oder Unterklassen finden. Ich bin mir auch nicht sicher, inwieweit führende Nullen oder deren Fehlen ein Problem sein werden. Hat jemand eine gute Richtung, um mich zu zeigen?

Sie müssen den Radix angeben . Es gibt eine Überladung, Integer#parseInt()die es Ihnen ermöglicht.

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

Dies könnte funktionieren:

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

funktioniert einwandfrei, wenn Sie mit positiven Zahlen arbeiten, aber wenn Sie mit vorzeichenbehafteten Zahlen arbeiten müssen, müssen Sie möglicherweise Ihre Zeichenfolge mit Vorzeichen erweitern und dann in eine Int konvertieren

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 

Ich hoffe das hilft!

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

Ich schätze, ich langweile mich noch mehr! Hassans Antwort wurde geändert, um korrekt zu funktionieren.

Für mich habe ich NumberFormatException bekommen, als ich versucht habe, mit den negativen Zahlen umzugehen. Ich habe Folgendes für die negativen und positiven Zahlen verwendet.

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

Output : -9

Die Version von Java's Integer.parseInt (Text) wurde korrigiert, um mit negativen Zahlen zu arbeiten:

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

Ich liebe Loops! Yay!

String myString = "1001001"; //73

While-Schleife mit Akkumulator von links nach rechts ( ländert sich nicht):

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

Von rechts nach links mit 2 Loop-Vars, inspiriert von Convert boolean to int in Java (absolut schrecklich):

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;

Eine etwas vernünftigere Implementierung:

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

Eine lesbare Version: p

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

Wenn Sie sich Sorgen um die Leistung machen Integer.parseInt()und Math.pow()zu teuer sind. Sie können die Bitmanipulation verwenden, um dasselbe doppelt so schnell auszuführen (basierend auf meiner Erfahrung):

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

Wo

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

Ausgabe:

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