# Java Convert Octal to Decimal

To convert an octal number to a decimal number in Java, you can use the `parseInt()` method of the `Integer` class, specifying the radix as 8 (which is the base of octal numbers). Here is an example code snippet:

```String octalNumber = "17"; // example octal number
int decimalNumber = Integer.parseInt(octalNumber, 8);
System.out.println(decimalNumber); // prints 15
```

In the code above, the `parseInt()` method takes two arguments: the first argument is the octal number as a string, and the second argument is the radix, which is 8 in this case.

Note that the result is stored in an `int` variable `decimalNumber`. If the octal number is too large to fit in an `int`, you may need to use a `long` variable instead.

Also note that the octal number must be represented as a string in order to use the `parseInt()` method with a radix. If you have an octal number as an integer literal in your code, you can convert it to a string using the `Integer.toString()` method, specifying the radix as 8, like this:

```int octalNumber = 017; // example octal number as integer literal
String octalString = Integer.toString(octalNumber, 8);
int decimalNumber = Integer.parseInt(octalString, 8);
System.out.println(decimalNumber); // prints 15
```

In this example, the octal number is specified as an integer literal with a leading 0, which indicates that it is an octal number. The `toString()` method is used to convert the octal number to a string representation with a radix of 8, which is then passed to the `parseInt()` method to convert it to a decimal number.

### Java Octal to Decimal conversion: Integer.parseInt()

Yes, you can use the `Integer.parseInt()` method to convert an octal number to a decimal number in Java by specifying the radix as 8, which is the base of octal numbers. Here’s an example:

```String octalStr = "17"; // octal number as string
int decimal = Integer.parseInt(octalStr, 8);
System.out.println(decimal); // prints 15
```

In this example, the `Integer.parseInt()` method takes two arguments: the first argument is the octal number as a string, and the second argument is the radix, which is 8 in this case. The method returns an `int` value that represents the decimal equivalent of the octal number.

Note that the `parseInt()` method can throw a `NumberFormatException` if the string is not a valid octal number. To handle this exception, you can wrap the code in a try-catch block, like this:

```String octalStr = "17"; // octal number as string
try {
int decimal = Integer.parseInt(octalStr, 8);
System.out.println(decimal); // prints 15
} catch (NumberFormatException e) {
System.out.println("Invalid octal number");
}
```

This code catches the `NumberFormatException` if the string is not a valid octal number and prints an error message.

### Java Octal to Decimal conversion: Custom Logic

To convert an octal number to a decimal number in Java using custom logic, you can implement a simple algorithm that involves iterating over the digits of the octal number and multiplying them by the corresponding power of 8, starting from the rightmost digit. Here’s an example:

```String octalStr = "17"; // octal number as string
int decimal = 0;
int power = 0;
for (int i = octalStr.length() - 1; i >= 0; i--) {
int digit = octalStr.charAt(i) - '0';
decimal += digit * Math.pow(8, power);
power++;
}
System.out.println(decimal); // prints 15
```

In this example, the `for` loop iterates over the digits of the octal number from right to left using the `charAt()` method of the string. For each digit, the code subtracts the character code of ‘0’ to get the actual integer value of the digit. Then, it multiplies the digit by the corresponding power of 8, which is calculated using the `Math.pow()` method. Finally, it adds the result to the `decimal` variable.

Note that the `Math.pow()` method returns a `double` value, which is automatically cast to an `int` when added to the `decimal` variable. This is safe as long as the resulting decimal value fits within the range of an `int`. If the octal number is too large to fit within an `int`, you may need to use a `long` variable instead.

Also note that this algorithm assumes that the input octal number is a valid string representation of an octal number. If the input string is not a valid octal number, the algorithm may produce incorrect results or throw an exception. You can add input validation code to check for this.