How To Convert Binary Number To Decimal In Java

The number systems in binary and decimal are widely used in computing. A number system with a base of two is called binary, while a base of ten is called decimal.

Although computers use binary to convey information and commands, people typically prefer the decimal number system. Popular computer language Java has built-in functions that allow you to convert a binary integer to a decimal value.

We will talk about the several ways to convert a binary number to a decimal number in Java in this blog post.

Need to convert binary number to decimal in java

Here are some points that explain why there is a need to convert binary numbers to decimal in Java:

Humans are more comfortable with decimal numbers: Humans typically find working with decimal numbers to be easier than working with binary numbers, which computers employ to express data and instructions. In order to make binary data more clear and intelligible, we may need to convert it to decimal.
Interpreting data correctly: To make sense of binary data, it may occasionally be necessary to translate it into a decimal number. For instance, in order to comprehend and interpret binary data when working with file systems or networking protocols, we may need to convert it to a decimal number.
Performing calculations: We might occasionally need to make computations on binary data. For instance, we could need to conduct bitwise operations or add or subtract binary numbers. We may need to convert the binary data to decimal first because it is frequently simpler to execute these computations on decimal integers.
Analyzing data: To perform statistical analysis or create graphs and charts, it may be required to convert binary data to decimal while studying data.
Compatibility with current systems: Certain current systems may only be able to handle data in decimal form. To ensure compatibility with the current system, we might need to convert binary data to decimal in these circumstances.

Different methods to change binary number to decimal in java

Using Integer.parseInt() method
Using BigInteger class
Writing a custom function

Detailed Explanation:

1. Using the Integer.parseInt() method:

This function converts a binary number to a decimal number using the built-in parseInt() method of the Integer class. The binary number as a string and the number system’s foundation are the method’s two required inputs (in this case, 2 for binary). The method returns the binary number’s integer representation in decimal form.

Advantages:

This method is simple and easy to use.
It is built into the Java language and does not require any external libraries.

Disadvantages:

This method is only suitable for converting small binary numbers to decimal. It may not work for very large binary numbers.

Sample code:

String binary = "11011010010101100101";
int decimal = Integer.parseInt(binary, 2);
System.out.println(decimal);

Sample output:

Code Explanation:

We define a string variable “binary” that contains a binary number.
We call the parseInt() method of the Integer class, passing the “binary” string as input and specifying that the base of the number system is 2 (for binary).
The method returns the decimal equivalent of the binary number, which is stored in the “decimal” variable.
We print the decimal number to the console.

2. Making use of the BigInteger class:

This method uses the BigInteger class in Java to convert a binary number to a decimal number. The method takes two parameters: the binary number as a string, and the base of the number system (in this case, 2 for binary). The method returns the decimal equivalent of the binary number as a BigInteger object.

Advantages:

The BigInteger class can handle very large binary numbers.

Disadvantages:

This method is slower and more resource-intensive than the parseInt() method.
It requires importing the BigInteger class from the java.math package.

Sample code:

String binary = "11011010010101100101";
BigInteger decimal = new BigInteger(binary, 2);
System.out.println(decimal);

Sample output:

Code Explanation:

We define a string variable “binary” that contains a binary number.
We create a new BigInteger object by passing the “binary” string as input and specifying that the base of the number system is 2 (for binary).
The BigInteger object stores the decimal equivalent of the binary number.
We print the decimal number to the console.

3. Writing a custom function:

This method involves writing a custom function to convert a binary number to a decimal number. The function takes one parameter: the binary number as a string. The function returns the decimal equivalent of the binary number as an integer.

Advantages:

This method allows for more control and customization than the other two methods.
It does not require importing any external libraries.

Disadvantages:

This method requires more code and is less concise than the other two methods.
It may not be as efficient for very large binary numbers.

Sample code:

public static int convertBinaryToDecimal(String binary) {
    int decimal = 0;
    int power = 0;
    for (int i = binary.length() - 1; i >= 0; i--) {
        int bit = binary.charAt(i) - '0';
        decimal += bit * Math.pow(2, power);
        power++;
    }
    return decimal;
}

String binary = "11011010010101100101";
int decimal = convertBinaryToDecimal(binary);
System.out.println(decimal);

Sample output:

Code Explanation:

We define a custom function named “convertBinaryToDecimal” that takes a string parameter “binary” representing the binary number.
Inside the function, we define two integer variables “decimal” and “power”.
We use a for loop to iterate over each character in the binary string from right to left.
For each character, we convert it to an integer by subtracting the character ‘0’ (the Unicode value for the digit 0) and store it in a variable “bit”.
We calculate the decimal equivalent of the bit using the formula decimal += bit * 2^power, where “^” denotes exponentiation.
We increment the “power” variable for each iteration of the loop.
After the loop, we return the decimal value.
In the main code, we define a string variable “binary” that contains a binary number, and call the “convertBinaryToDecimal” function to convert it to decimal.
We print the decimal number to the console.

Best method out of three techniques?

The Integer.parseInt() method is the best method to convert a binary number to decimal in Java for several reasons:

Simplicity: The Integer.parseInt() method is simple and easy to use, requiring only a single line of code to convert a binary string to a decimal number.
Efficiency: The Integer.parseInt() method is optimized for performance, making it the fastest method to convert a binary string to a decimal number.
Built-in Java Functionality: The Integer.parseInt() method is a built-in Java function that is included in the Java API, which means that it does not require any external libraries or custom functions to be imported or written.
Error Handling: The Integer.parseInt() method includes error handling, which means that it will throw a NumberFormatException if the input string is not a valid binary string, which can be useful for debugging and catching errors.

Overall, the Integer.parseInt() method is the recommended method to convert a binary number to decimal in Java due to its simplicity, efficiency, built-in Java functionality, and error handling capabilities.

Sample Problem:

Problem 1: Binary Addition: Write a Java program that accepts two binary numbers as input and outputs their sum in decimal format Using Integer.parseInt() method.

Solution:

First, we import the Scanner class from the java.util package to read input from the user.
We then prompt the user to enter the first and second binary numbers using the Scanner object.
The parseInt() method of the Integer class is used to convert the binary strings to their decimal equivalent values.
We then perform the addition of the decimal values obtained in step 3.
Finally, we print out the decimal equivalent of each binary number and their sum in decimal format.

Code:

import java.util.Scanner;

// Define a class named "BinaryAddition"
public class BinaryAddition {

    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        
        // Prompt the user to enter the first binary number
        System.out.print("Enter the first binary number: ");

        String binary1 = input.next();
        
        // Prompt the user to enter the second binary number
        System.out.print("Enter the second binary number: ");

        String binary2 = input.next();

        // Convert binary numbers from a String to an integer 

        int decimal1 = Integer.parseInt(binary1, 2);
       
        int decimal2 = Integer.parseInt(binary2, 2);

        int sum = decimal1 + decimal2;

        
        System.out.println("The decimal equivalent of " + binary1 + " is " + decimal1);
        
        System.out.println("The decimal equivalent of " + binary2 + " is " + decimal2);
        
        System.out.println("The sum of " + binary1 + " and " + binary2 + " is " + sum);
    }
}

Output:

Enter the first binary number: 1010
Enter the second binary number: 1101
The decimal equivalent of 1010 is 10
The decimal equivalent of 1101 is 13
The sum of 1010 and 1101 is 23

In this example, the program prompts the user to enter two binary numbers, 1010 and 1101. It then converts the binary numbers to their decimal equivalent values using the parseInt() method and performs addition to obtain the sum of the two decimal values.

Finally, it prints out the decimal equivalent of each binary number and their sum in decimal format. In this case, the decimal equivalent of 1010 is 10, the decimal equivalent of 1101 is 13, and their sum is 23.

Problem 2: Binary Search: Write a Java program that implements binary search on a sorted array of binary numbers, where each binary number is represented as a string. The program should convert each binary number to its decimal equivalent before performing the search Using BigInteger class.

Solution:

First, we import the required classes and packages.
We create a Scanner object to read input from the user.
We prompt the user to enter the number of elements in the array.
We create two arrays – a string array to store the binary numbers entered by the user, and a BigInteger array to store their decimal equivalent values.
We then use a for loop to read each binary number entered by the user and convert it to its decimal equivalent value using the BigInteger class.
We sort the decimalArray using the sort() method of the Arrays class.
We prompt the user to enter the binary number to be searched and convert it to its decimal equivalent value using the BigInteger class.
We perform a binary search on the sorted decimalArray using the binarySearch() method of the Arrays class.
If the binary number is found, we print its index in the array. Otherwise, we print a message indicating that the binary number is not found in the array.

Code:

// Import necessary classes from the java.util and java.math packages
import java.util.Arrays;
import java.util.Scanner;
import java.math.BigInteger;

public class BinarySearch {
    
    public static void main(String[] args) {
    
        Scanner input = new Scanner(System.in);
        
        // Prompt the user to enter the number of elements in the array
        System.out.print("Enter the number of elements in the array: ");
        int n = input.nextInt();
        
        // Create two arrays
        String[] binaryArray = new String[n];
        BigInteger[] decimalArray = new BigInteger[n];
        
        // Loop through each element of the binary array
        for (int i = 0; i < n; i++) {
            System.out.print("Enter binary number " + (i + 1) + ": ");
            // Read the binary number entered by the user and store it in the binaryArray
            binaryArray[i] = input.next();
            // Convert the binary string to a decimal value and store it in the decimalArray
            decimalArray[i] = new BigInteger(binaryArray[i], 2);
        }
        
        // Sort the decimalArray in ascending order
        Arrays.sort(decimalArray);
        
        System.out.print("Enter the binary number to be searched: ");
        String binarySearch = input.next();
        // Convert the binary search string to a decimal value and store it as a BigInteger
        BigInteger decimalSearch = new BigInteger(binarySearch, 2);
        
        // Search for the decimalSearch value in the sorted decimalArray using binary search
        int index = Arrays.binarySearch(decimalArray, decimalSearch);
        
        if (index < 0) {
            System.out.println("The binary number " + binarySearch + " is not found in the array.");
        } 
              else {
            System.out.println("The binary number " + binarySearch + " is found at index " + index + " in the array.");
        }
    }
}

Output:

Enter the number of elements in the array: 5
Enter binary number 1: 00001
Enter binary number 2: 00011
Enter binary number 3: 00100
Enter binary number 4: 01000
Enter binary number 5: 10000
Enter the binary number to be searched: 00100
The binary number 00100 is found at index 2 in the array.

In this example, the program prompts the user to enter the number of elements in the array and the binary numbers to be searched. It converts each binary number to its decimal equivalent using the BigInteger class and stores them in a BigInteger array.

The decimal array is then sorted using the sort() method of the Arrays class. The binary number to be searched is converted to its decimal equivalent using the BigInteger class and a binary search is performed on the sorted decimal array using the binarySearch() method of the Arrays class.

Finally, the program outputs the index of the binary number in the array if it is found, otherwise it outputs a message indicating that the binary number is not found in the array.

In this case, the binary number 00100 is found at index 2 in the array.

Problem 3: Binary to Decimal Converter: Write a Java program that prompts the user to enter a binary number and outputs its decimal equivalent using the Math.pow() method.

Solution:

First, we import the java.util.Scanner class for taking input from the user.
Then, we create a Scanner object to read the user input.
We prompt the user to enter a binary number and store the input in a String variable called binary.
We close the Scanner object to prevent resource leaks.
We initialize two variables decimal and power to 0. decimal will store the decimal equivalent of the binary number, while power will keep track of the power of 2 for each digit of the binary number.
We loop through the binary number from right to left using a for loop.
For each digit of the binary number, we check if it is 1. If it is, we add 2^power to decimal.
We increment the power variable after each iteration of the loop.
After the loop, we output the decimal equivalent of the binary number using System.out.println().
We concatenate the binary number and decimal equivalent to the output using the + operator.

Code:

// Import necessary classes from the java.util package
import java.util.Scanner;

public class BinaryToDecimalConverter {

   public static void main(String[] args) {
      
      Scanner scanner = new Scanner(System.in);
      
      // Prompt the user to enter a binary number
      System.out.print("Enter a binary number: ");
    
      String binary = scanner.nextLine();
   
      scanner.close();
      
      // Initialize variables to store the decimal equivalent of the binary number and the power of 2 to be raised
      int decimal = 0;
      int power = 0;
      
      // Loop through each character in the binary string starting from the rightmost digit
      for (int i = binary.length() - 1; i >= 0; i--) {
         // If the character is '1', add 2 raised to the current power to the decimal equivalent
         if (binary.charAt(i) == '1') {
            decimal += Math.pow(2, power);
         }
         // Increment the power of 2 for the next digit
         power++;
      }
      
      System.out.println("The decimal equivalent of " + binary + " is " + decimal);
   }
}

Sample Input/Output:

Enter a binary number: 10101
The decimal equivalent of 10101 is 21

Conclusion:

In conclusion, there are a lot of ways to do the essential programming task of converting a binary number to a decimal form in Java. The built-in Integer.parseInt() technique, the Math.pow() function, and a custom conversion function were the three main approaches covered in this article.

The Integer.parseInt() method was chosen as the best alternative among them because of its ease of use, effectiveness, compatibility with built-in Java features, and ability to handle errors. It is an efficient approach that converts a binary text to a decimal number with just one line of code.

Regardless of the method chosen, it is important to understand the underlying principles of binary and decimal conversion in order to write efficient and effective code.

With this knowledge and the various methods available in Java, converting binary numbers to decimal should be a straightforward and manageable task for any programmer.

24×7 Live Java Homework Help From Expert Tutors! Get Help Now

Author:

Sanskar Aggarwal

I have experience in multiple programming languages: C++ , Java , Python, Flutter and good command over Data structure. I take ownership of my work and believe in constant of scaling interested in learning new technology and ready to take up new challenges. Follow: