Octal To Binary Conversion In Java Program

Octal and binary number systems are fundamental concepts in computer science. Converting between them is a common operation. Understanding how to perform this conversion programmatically in Java is a valuable skill.

In this article, you will learn how to convert an octal number to its binary equivalent using a Java program.

Problem Statement

The task is to write a Java program that takes an octal number as input from the user and outputs its corresponding binary representation. Octal numbers use a base-8 system (digits 0-7), while binary numbers use a base-2 system (digits 0-1).

Example

If the input octal number is 17, the expected binary output is 001111.

Background & Knowledge Prerequisites

To understand this conversion, you should be familiar with:

• Octal Number System: Base-8 system, uses digits 0-7.
• Binary Number System: Base-2 system, uses digits 0-1.
• Java Basics:
• Variables and data types (e.g., String, int).
• Input/Output using Scanner.
• Loops (e.g., for loop).
• Conditional statements (e.g., switch statement).
• String manipulation.

Use Cases or Case Studies

• Low-level Programming: When working with hardware or embedded systems, understanding and converting between different number bases is crucial.
• Data Representation: Representing data efficiently in memory often involves binary, and octal can sometimes be a more human-readable intermediate form.
• Networking: IP addresses and subnet masks can sometimes be represented in octal for specific configurations, requiring conversion to binary for network devices.
• File Permissions (Unix/Linux): Octal numbers are commonly used to represent file permissions (e.g., 755), which are fundamentally binary flags.
• Educational Tools: Developing tools to help students understand number system conversions.

Solution Approaches

We will explore one common and straightforward approach for octal to binary conversion: converting each octal digit to its 3-bit binary equivalent.

Approach 1: Digit-by-Digit Conversion

This approach involves iterating through each digit of the octal number and replacing it with its 3-bit binary equivalent.

• One-line summary: Convert each octal digit to its 3-bit binary string and concatenate them.

// Octal to Binary Converter
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt the user to enter an octal number
        System.out.print("Enter an octal number: ");
        String octalNumber = scanner.nextLine();

        // Step 3: Initialize a StringBuilder to store the binary equivalent
        StringBuilder binaryNumber = new StringBuilder();

        // Step 4: Iterate through each character (digit) of the octal number
        for (int i = 0; i < octalNumber.length(); i++) {
            char octalDigit = octalNumber.charAt(i);

            // Step 5: Use a switch statement to convert each octal digit to its 3-bit binary equivalent
            switch (octalDigit) {
                case '0':
                    binaryNumber.append("000");
                    break;
                case '1':
                    binaryNumber.append("001");
                    break;
                case '2':
                    binaryNumber.append("010");
                    break;
                case '3':
                    binaryNumber.append("011");
                    break;
                case '4':
                    binaryNumber.append("100");
                    break;
                case '5':
                    binaryNumber.append("101");
                    break;
                case '6':
                    binaryNumber.append("110");
                    break;
                case '7':
                    binaryNumber.append("111");
                    break;
                default:
                    // Handle invalid octal digits
                    System.out.println("Invalid octal digit: " + octalDigit);
                    scanner.close();
                    return; // Exit the program if an invalid digit is found
            }
        }

        // Step 6: Print the resulting binary number
        System.out.println("Binary equivalent: " + binaryNumber.toString());

        // Step 7: Close the scanner
        scanner.close();
    }
}

Run

• Sample output:

Enter an octal number: 17
Binary equivalent: 001111

Enter an octal number: 456
Binary equivalent: 100101110

Enter an octal number: 8
Invalid octal digit: 8

• Stepwise explanation:

1. Input: The program first prompts the user to enter an octal number, which is read as a String. Reading it as a string simplifies iterating through its digits.
2. Initialization: A StringBuilder named binaryNumber is created. StringBuilder is efficient for concatenating strings in a loop.
3. Iteration: A for loop iterates through each character of the input octalNumber string.
4. Digit Conversion: Inside the loop, a switch statement checks the value of each octalDigit.

• Each octal digit (0-7) has a direct 3-bit binary equivalent. For example, '0' is "000", '1' is "001", '2' is "010", and so on.
• The corresponding 3-bit binary string is appended to the binaryNumber StringBuilder.
• If an invalid digit (not 0-7) is encountered, an error message is printed, and the program exits.

1. Output: After processing all digits, the final binary string is obtained from the StringBuilder using toString() and printed to the console.
2. Resource Management: The Scanner object is closed to release system resources.

Conclusion

Converting an octal number to binary is a straightforward process when you understand the relationship between the two number systems. By converting each octal digit into its 3-bit binary equivalent and concatenating these bits, you can effectively perform the conversion in Java. This method is robust and handles invalid octal inputs gracefully.

Summary

• Octal to binary conversion involves replacing each octal