Jak przekonwertować ciąg binarny na liczbę podstawową 10 w Javie

Question

Mam tablicę ciągów, które reprezentują liczby binarne (bez zer wiodących), które chcę przekonwertować na odpowiadające im liczby bazowe 10. Rozważ:

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

Jaki jest najlepszy sposób postępowania? Badałem java.lang.number. * Bez znajdowania bezpośredniej metody konwersji. Integer.parseInt(b) daje liczbę całkowitą EQUAL do łańcucha ... np. 1001 staje się 1,001 zamiast 9 ... i nie wydaje się zawierać parametru dla bazy wyjściowej. toBinaryString powoduje konwersję w niewłaściwym kierunku. Podejrzewam, że będę musiał przeprowadzić konwersję wieloetapową, ale nie mogę znaleźć właściwej kombinacji metod lub podklas. Nie jestem również pewien, w jakim stopniu wiodące zera lub ich brak będą problemem. Czy ktoś ma jakieś dobre wskazówki, żeby mi wskazać?

Answer 1

Musisz specify the radix. Istnieje przeciążenie Integer#parseInt(), które umożliwia.

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

Answer 2

Może to działa:

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

Chyba jestem jeszcze bardziej znudzony! Zmodyfikowano odpowiedź Hassana na poprawne działanie.

Answer 4

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

działa dobrze, jeśli masz do czynienia z liczbami dodatnimi, ale jeśli trzeba radzić sobie z podpisanych liczb może trzeba podpisać przedłużyć swój ciąg następnie przekonwertować na 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 

Mam nadzieję, że pomaga !

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

Kocham pętle! Yay!

String myString = "1001001"; //73 

Podczas gdy pętla z akumulatorem, od lewej do prawej (l nie zmienia):

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

prawej do lewej, z 2 Vars pętlowych, inspirowany Convert boolean to int in Java (absolutnie straszne):

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; 

Nieco rozsądniejsza implementacja:

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

czytelnej wersji: 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

Fixed wersja Javy Integer.parseInt (tekst) do pracy z liczbami ujemnymi:

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

Jeśli martwisz się o wydajność, Integer.parseInt() i Math.pow() są za drogie.Można użyć bitowe manipulacji, aby zrobić to samo dwa razy szybciej (na podstawie mojego doświadczenia):

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

Gdzie

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

wyjściowa:

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