如何在 Java 中将二进制字符串转换为基数为10的整数

我有一个字符串数组，它表示二进制数(没有前导零) ，我想把它们转换成相应的10进制数。考虑一下:

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

最好的办法是什么？我一直在研究 java.lang.number。* 没有找到直接转换的方法。Integer.parseInt(b)对 String 生成一个整数 EQUAL... 例如，1001变成了1,001而不是9... 而且似乎没有包含用于输出基的参数。toBinaryString的转换方向是错误的。我怀疑我需要进行多步转换，但似乎找不到方法或子类的正确组合。我也不确定前导零或前导零的缺少在多大程度上是一个问题。有人能告诉我怎么走吗？

257498 次浏览
小开
最佳答案

你需要 指定基数。有一个超载的 Integer#parseInt()允许你。

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

这可能会奏效:

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

我想我更无聊了! 修改哈桑的回答，以正确运作。

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

如果处理的是正数，那么就可以了，但是如果处理的是有符号数，那么可能需要对扩展字符串进行符号化，然后转换为整型

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

我希望这能有所帮助！

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

我喜欢循环，耶！

String myString = "1001001"; //73

当使用累加器循环时，从左到右(l不变) :

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

从右到左2个循环变量，灵感来自 在 Java 中将 boolean 转换为 int(绝对可怕) :

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;

更合理的实施方式:

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

可读的版本: p

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

固定版本的 java 的 Integer.parseInt (文本)处理负数:

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

如果你担心性能，Integer.parseInt()和 Math.pow()是太昂贵了。根据我的经验，你可以使用位操作将同一件事情的速度提高一倍:

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

在哪里

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

产出:

 Input Number: 87 toBinary 1010111
Output Number: 87 toBinary 1010111
小开

对我来说，当我试图处理负数时，我得到了 NumberFormatException。我使用下面的负数和正数。

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


Output : -9
小开

现在你想做从二进制字符串到十进制但后，你可能需要相反的方法。就在下面。

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

使用位移比 Math.pow更优雅、更快。只需用 val <<= 1将数字(0或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;
}

示例使用

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

指纹11

小开

如果给定的是字符串，也可以使用此方法将二进制转换为十进制整数。(Java 语言)

static int binaryTodecimal(String s){
int i= -1;
char[] str = s.toCharArray();
int dec_val= 0;
    

for (int j=str.length-1; j>=0 ;j-- ){
int k= Integer.valueOf(str[j]) - '0';
i = i+1;
dec_val += k*(Math.pow(2, i));
        

}
System.out.println(dec_val);
}

提交答案