Java'da İkili Dizeyi 10 tabanlı tam sayıya dönüştürme

İkili sayıları (baştaki sıfırlar olmadan) temsil eden bir Dizeler dizisi var ve bunlara karşılık gelen taban 10 sayılarına dönüştürmek istiyorum. Düşünmek:

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

Devam etmenin en iyi yolu nedir? Doğrudan bir dönüştürme yöntemi bulmadan java.lang.number. * 'I araştırıyorum. Integer.parseInt(b)Dizeye EQUAL bir tamsayı verir ... örneğin, 1001, 9 ... yerine 1,001 olur ve bir çıktı tabanı için bir parametre içermiyor gibi görünür. toBinaryStringdönüşümü yanlış yönde yapar. Çok adımlı bir dönüşüm yapmam gerekeceğinden şüpheleniyorum, ancak doğru yöntem veya alt sınıf kombinasyonunu bulamıyorum. Baştaki sıfırların veya eksikliklerinin ne ölçüde sorun olacağından da emin değilim. Beni yönlendirecek iyi yönleri olan var mı?

Tabanı belirtmeniz gerekir . Size Integer#parseInt()izin veren bir aşırı yük var .

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

Bu işe yarayabilir:

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

pozitif sayılarla uğraşıyorsanız gayet iyi çalışıyor, ancak işaretli sayılarla uğraşmanız gerekiyorsa, dizenizi genişletip ardından Int'e dönüştürmeniz gerekebilir.

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 

Umarım bu yardımcı olur!

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

Sanırım daha da sıkıldım! Hassan'ın doğru çalışması için cevabı değiştirildi.

Negatif sayılarla uğraşmaya çalışırken benim için NumberFormatException aldım. Negatif ve pozitif sayılar için aşağıdakileri kullandım.

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

Output : -9

Java'nın Integer.parseInt (metin) sürümünün negatif sayılarla çalışması düzeltildi:

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

Döngülere bayılırım! Yaşasın!

String myString = "1001001"; //73

Akümülatörlü döngü sırasında soldan sağa ( ldeğişmez):

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

2 döngü değişkeniyle sağdan sola , Java'da Boolean'ı int'e dönüştürme esinlenerek (kesinlikle korkunç):

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;

Biraz daha makul bir uygulama:

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

Okunabilir bir versiyon: p

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

Performans konusunda endişeliyseniz Integer.parseInt()ve Math.pow()çok pahalıysanız. Aynı şeyi iki kat daha hızlı yapmak için bit manipülasyonunu kullanabilirsiniz (deneyimlerime göre):

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

Nerede

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

Çıktı:

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