**Get started with Spring 5 and Spring Boot 2, through the ***Learn Spring* course:

*Learn Spring*course:

Last modified: August 6, 2019

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

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

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

To use it, we need to prefix the number with 0B or 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);
}
```

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.

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

```
@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:

- 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:

- 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());
}
```

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

```
@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:

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

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

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());
}
```

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**:

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

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.

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.