1. Introduction

1.绪论

The binary number system uses 0s and 1s to represent numbers. Computers use binary numbers to store and perform operations on any data.

二进制数字系统使用0和1来表示数字。计算机使用二进制数来存储和执行对任何数据的操作。

In this tutorial, we’ll learn how to convert binary to decimal and vice versa. Also, we’ll perform addition and subtraction on them.

在本教程中，我们将学习如何将二进制转换为十进制，反之亦然。此外，我们还将对其进行加减运算。

2. Binary Literal

2.二进制文字

Java 7 introduced the binary literal. It simplified binary number usage.

Java 7引入了二进制字面。它简化了二进制数的使用。

To use it, we need to prefix the number with 0B or 0b:

要使用它，我们需要在数字前加上0B或0b。

@Test
public void given_binaryLiteral_thenReturnDecimalValue() {

    byte five = 0b101;
    assertEquals((byte) 5, five);

    short three = 0b11;
    assertEquals((short) 3, three);

    int nine = 0B1001;
    assertEquals(9, nine);

    long twentyNine = 0B11101;
    assertEquals(29, twentyNine);

    int minusThirtySeven = -0B100101;
    assertEquals(-37, minusThirtySeven);

}

3. Binary Number Conversion

3.二进制数字转换

In this section, we’ll learn how to convert a binary number into its decimal format and vice versa. Here, we’ll first use a built-in Java function for conversion, and then we’ll write our custom methods for the same.

在本节中，我们将学习如何将二进制数转换成十进制格式，反之亦然。在这里，我们将首先使用一个内置的Java函数进行转换，然后再编写我们的自定义方法来实现。

3.1. Decimal to a Binary Number

3.1.十进制数转为二进制数

Integer has a function named toBinaryString to convert a decimal number into its binary string:

Integer有一个名为toBinaryString的函数，可以将一个十进制数字转换为其二进制字符串。

@Test
public void given_decimalNumber_then_convertToBinaryNumber() {
    assertEquals("1000", Integer.toBinaryString(8));
    assertEquals("10100", Integer.toBinaryString(20));
}

Now, we can try to write our own logic for this conversion. Before writing the code, let’s first understand how to convert a decimal number into a binary one.

现在，我们可以尝试为这种转换编写自己的逻辑。在写代码之前，我们先了解一下如何将一个十进制的数字转换成二进制的。

To convert a decimal number n into its binary format, we need to:

要将一个十进制数n转换成其二进制格式，我们需要。

Divide n by 2, noting the quotient q and the remainder r
Divide q by 2, noting its quotient and remainder
Repeat step 2 until we get 0 as the quotient
Concatenate in reverse order all remainders

Let’s see an example of converting 6 into its binary format equivalent:

让我们看一个将6转换为二进制格式的例子。

First, divide 6 by 2: quotient 3, remainder 0
Then, divide 3 by 2: quotient 1, remainder 1
And finally, divide 1 by 2: quotient 0, remainder 1
110

Let’s now implement the above algorithm:

现在我们来实现上述算法。

public Integer convertDecimalToBinary(Integer decimalNumber) {

    if (decimalNumber == 0) {
        return decimalNumber;
    }

    StringBuilder binaryNumber = new StringBuilder();
    Integer quotient = decimalNumber;

    while (quotient > 0) {
        int remainder = quotient % 2;
        binaryNumber.append(remainder);
        quotient /= 2;
    }

    binaryNumber = binaryNumber.reverse();
    return Integer.valueOf(binaryNumber.toString());
}

3.2. Binary to a Decimal Number

3.2.二进制到十进制数字

To parse a binary string, the Integer class provides a parseInt function:

为了解析二进制字符串，Integer类提供了一个parseInt函数。

@Test
public void given_binaryNumber_then_ConvertToDecimalNumber() {
    assertEquals(8, Integer.parseInt("1000", 2));
    assertEquals(20, Integer.parseInt("10100", 2));
}

Here, the parseInt function takes two parameters as input:

这里，parseInt函数需要两个参数作为输入。

Binary string to be converted
Radix or base of the number system in which input string has to be converted

Now, let’s try to write our own logic to convert a binary number into decimal:

现在，让我们试着写出自己的逻辑，将二进制数字转换成十进制。

Start from with rightmost digit
Multiply each digit with 2^{position} of that digit – here, rightmost digit’s position is zero and it increases as we move to the left side
Add the result of all the multiplications to get the final decimal number

Again, let’s see our method in action:

再一次，让我们看看我们的方法在行动。

First, 101011 = (1*2^5) + (0*2^4) + (1*2^3) + (0*2^2) + (1*2^1) + (1*2^0)
Next, 101011 = (1*32) + (0*16) + (1*8) + (0*4) + (1*2) + (1*1)
Then, 101011 = 32 + 0 + 8 + 0 + 2 + 1
And finally, 101011 = 43

Let’s finally code the above steps:

最后让我们对上述步骤进行编码。

public Integer convertBinaryToDecimal(Integer binaryNumber) {

    Integer decimalNumber = 0;
    Integer base = 1;

    while (binaryNumber > 0) {
        int lastDigit = binaryNumber % 10;
        binaryNumber = binaryNumber / 10;
        decimalNumber += lastDigit * base;
        base = base * 2;
    }
    return decimalNumber;
}

4. Arithmetic Operations

4.算术运算

In this section, we’ll concentrate on performing the arithmetic operations on binary numbers.

在本节中，我们将专注于对二进制数字进行算术运算。

4.1. Addition

4.1.增加

Just like the decimal number addition, we start adding the numbers from the rightmost digit.

就像十进制数字加法一样，我们从最右边的数字开始加。

While adding two binary digits, we need to remember the following rules:

当两个二进制数字相加时，我们需要记住以下规则。

0 + 0 = 0
0 + 1 = 1
1 + 1 = 10
1 + 1 + 1 = 11

These rules can be implemented as:

这些规则可以实施为。

public Integer addBinaryNumber(Integer firstNum, Integer secondNum) {
    StringBuilder output = new StringBuilder();
    int carry = 0;
    int temp;
    while (firstNum != 0 || secondNum != 0) {
        temp = (firstNum % 10 + secondNum % 10 + carry) % 2;
        output.append(temp);

        carry = (firstNum % 10 + secondNum % 10 + carry) / 2;
        firstNum = firstNum / 10;
        secondNum = secondNum / 10;
    }
    if (carry != 0) {
        output.append(carry);
    }
    return Integer.valueOf(output.reverse().toString());
}

4.2. Subtraction

4.2.减法

There are many ways to subtract binary numbers. In this section, we’ll learn a one’s complement method to do subtraction.

二进制数字的减法有很多方法。在本节中，我们将学习用一元补码的方法做减法。

Let’s first understand what is one’s complement of a number.

让我们首先了解什么是一个数字的补数。

One’s complement of a number is a number obtained by negating each digit of the binary number. That means just replace 1 by 0 and 0 by 1:

一个数字的补码是通过否定二进制数字的每个数字而得到的数字。这意味着只需用0替换1，用1替换0。

public Integer getOnesComplement(Integer num) {
    StringBuilder onesComplement = new StringBuilder();
    while (num > 0) {
        int lastDigit = num % 10;
        if (lastDigit == 0) {
            onesComplement.append(1);
        } else {
            onesComplement.append(0);
        }
        num = num / 10;
    }
    return Integer.valueOf(onesComplement.reverse().toString());
}

To do subtraction of two binary numbers using one’s complement, we need to:

要用一补做两个二进制数的减法，我们需要。

Calculate the one’s complement of the subtrahend s
Add s and the minuend
If a carry gets generated in step 2, then add that carry to step 2’s result to get the final answer.
If a carry is not generated in step 2, then the one’s complement of step 2’s result is the final answer. But in this case, the answer is negative

Let’s implement the above steps:

让我们来实施上述步骤。

public Integer substractBinaryNumber(Integer firstNum, Integer secondNum) {
    int onesComplement = Integer.valueOf(getOnesComplement(secondNum));
    StringBuilder output = new StringBuilder();
    int carry = 0;
    int temp;
    while (firstNum != 0 || onesComplement != 0) {
        temp = (firstNum % 10 + onesComplement % 10 + carry) % 2;
        output.append(temp);
        carry = (firstNum % 10 + onesComplement % 10 + carry) / 2;

        firstNum = firstNum / 10;
        onesComplement = onesComplement / 10;
    }
    String additionOfFirstNumAndOnesComplement = output.reverse().toString();
    if (carry == 1) {
        return addBinaryNumber(Integer.valueOf(additionOfFirstNumAndOnesComplement), carry);
    } else {
        return getOnesComplement(Integer.valueOf(additionOfFirstNumAndOnesComplement));
    }
}

5. Conclusion

5.总结

In this article, we learned how to convert binary numbers into decimal ones and vice versa. Then, we performed arithmetic operations such as addition and subtraction on binary numbers.

在这篇文章中，我们学习了如何将二进制数转换成十进制数，反之亦然。然后，我们对二进制数进行了算术运算，如加法和减法。

The complete code used in this article is available over on GitHub.

本文中使用的完整代码可在GitHub上获得。