Een binaire tekenreeks converteren naar een geheel getal met grondtal 10 in Java

Ik heb een array van strings die binaire getallen vertegenwoordigen (zonder voorloopnullen) die ik wil converteren naar hun corresponderende basis 10-getallen. Overweeg:

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

Wat is de beste manier om verder te gaan? Ik heb java.lang.number.* onderzocht zonder een directe conversiemethode te vinden. Integer.parseInt(b)levert een geheel getal EQUAL op aan de tekenreeks… bijv. 1001 wordt 1,001 in plaats van 9… en lijkt geen parameter voor een uitvoerbasis te bevatten. toBinaryStringdoet de conversie in de verkeerde richting. Ik vermoed dat ik een conversie in meerdere stappen moet doen, maar ik kan de juiste combinatie van methoden of subklassen niet vinden. Ik weet ook niet zeker in hoeverre voorloopnullen of het ontbreken daarvan een probleem zullen zijn. Heeft iemand een goede routebeschrijving naar mij?

Antwoord 1, autoriteit 100%

Je moet specificeer de wortel. Er is een overbelasting van Integer#parseInt()waardoor u dat kunt.

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

Antwoord 2, autoriteit 8%

Dit zou kunnen werken:

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

Antwoord 3, autoriteit 3%

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

werkt prima als je te maken hebt met positieve getallen, maar als je te maken hebt met getekende getallen, moet je misschien ondertekenen, verleng je string en converteer naar een 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 

Ik hoop dat dat helpt!

Antwoord 4, autoriteit 2%

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

Antwoord 5

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

Ik denk dat ik me nog meer verveel! Hassans antwoord aangepast om correct te functioneren.

Antwoord 6

Voor mij kreeg ik NumberFormatException toen ik probeerde om te gaan met de negatieve getallen. Ik heb het volgende gebruikt voor de negatieve en positieve getallen.

System.out.println(Integer.parseUnsignedInt("11111111111111111111111111110111", 2));      
Output : -9

Antwoord 7

Het gebruik van bitshift is eleganter en sneller dan Math.pow. Gewoon bitshift de cijfers (0 of 1) in positie met val <<= 1

// parse an unsigned binary string, valid up to 31 bits
static int binaryToBase10(String binaryString) {
    int val = 0;
    for (char c : binaryString.toCharArray()) {
        val <<= 1;
        val += c-'0';
    }
    return val;
}

Voorbeeld gebruik

int val = binaryToBase10("1011");
System.out.println(val);

afdrukken 11

Antwoord 8

Vaste versie van Java’s Integer.parseInt(text) om met negatieve getallen te werken:

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

Antwoord 9

Ik ben dol op loops! Yay!

String myString = "1001001"; //73

Terwijl lus met accumulator, van links naar rechts (lverandert niet):

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

Van rechts naar links met 2 loop-vars, geïnspireerd door Boolean omzetten naar int in Java(absoluut verschrikkelijk):

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;

Een wat redelijkere implementatie:

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

Een leesbare versie :p

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

Antwoord 10

Als je je zorgen maakt over de prestaties, zijn Integer.parseInt()en Math.pow()te duur. Je kunt bitmanipulatie gebruiken om hetzelfde twee keer zo snel te doen (gebaseerd op mijn ervaring):

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

Waar

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

Uitvoer:

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

Antwoord 11

Nu wil je van binaire string naar Decimaal, maar Afterword, misschien heb je een tegenovergestelde methode nodig. Het staat hieronder.

public static String decimalToBinaryString(int value) {
    String str = "";
    while(value > 0) {
        if(value % 2 == 1) {
            str = "1"+str;
        } else {
            str = "0"+str;
        }
        value /= 2;
    }
    return str;
}