Comment convertir une chaîne binaire en un entier de base 10 en Java
j'ai un tableau de chaînes qui représentent des nombres binaires (sans zéros de tête) que je veux convertir en leur base 10 nombres correspondants. Prendre en considération:
binary 1011 becomes integer 11
binary 1001 becomes integer 9
binary 11 becomes integer 3 etc.
Quelle est la meilleure façon de procéder? J'ai été d'explorer java.lang.nombre.* sans trouver de méthode de conversion directe. Integer.parseInt(b) donne un entier égal à la chaîne...par exemple, 1001 devient 1 001 au lieu de 9...et ne semble pas inclure de paramètre pour une base de sortie. toBinaryString la conversion va dans la mauvaise direction. Je pense que je vais avoir besoin de faire une conversion en plusieurs étapes, mais ne semble pas trouver la bonne combinaison de méthodes ou de sous-classes. Je ne suis pas sûr non plus de la mesure dans laquelle les zéros de tête ou l'absence de celui-ci sera un problème. N'importe qui ont des bonnes directions à m'indiquer?
8 réponses
vous devez spécifier le radix . Il y a une surcharge de Integer#parseInt() qui vous permet de.
int foo = Integer.parseInt("1001", 2);
Cela peut fonctionner:
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);
fonctionne très bien si vous avez affaire à des nombres positifs, mais si vous avez besoin de traiter avec des nombres signés, vous pouvez avoir besoin de signer étendre votre chaîne puis convertir en 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
j'espère que ça aidera!
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;
}
je crois que je m'ennuie encore plus! Modifié la réponse de Hassan pour fonctionner correctement.
version corrigée de java Integer.parseInt(texte) pour travailler avec des nombres négatifs:
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;
}
si vous vous inquiétez pour la performance, Integer.parseInt() et Math.pow() sont trop chers. Vous pouvez utiliser la manipulation de bits pour faire la même chose deux fois plus vite (basé sur mon expérience):
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));
où
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;
}
sortie:
Input Number: 87 toBinary 1010111
Output Number: 87 toBinary 1010111
j'adore les boucles! Yay!!!
String myString = "1001001"; //73
boucle avec accumulateur, de gauche à droite ( l ne change pas):
int n = 0,
j = -1,
l = myString.length();
while (++j < l) n = (n << 1) + (myString.charAt(j) == '0' ? 0 : 1);
return n;
de droite à gauche avec 2 boucles vars, inspiré par convertir booléen en int en Java (absolument horrible):
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 peu plus raisonnable de mise en œuvre:
int n = 0,
j = myString.length(),
i = 1;
while (j-- != 0) n += (i = i << 1) * (myString.charAt(j) == '0' ? 0 : 1);
return n >> 1;
une version lisible: p
int n = 0;
for (int j = 0; j < myString.length(); j++) {
n *= 2;
n += myString.charAt(j) == '0' ? 0 : 1;
}
return n;