## 1. Overview

Base transformations for numbers are an everyday use case when working with numbers.

In this tutorial, **we’ll learn how to convert octal numbers to decimal and vice-versa in Kotlin**.

## 2. Octal to Decimal Conversion

In this section, we’ll learn how to convert octal values to decimal numbers.

### 2.1. Using *Integer.parseInt()* Method

Let’s start by **writing the ***octalToDecimalUsingParseInt()* method that uses the *parseInt()* method to convert the octal representation to decimal:

```
fun octalToDecimalUsingParseInt(octal: String): Int {
return Integer.parseInt(octal, 8)
}
```

We specify the *radix=8* as a parameter to parse the *octal* value from the base-8 number system.

Further, let’s verify the functional correctness of our function:

`Assertions.assertEquals(28, octalToDecimalUsingParseInt("34"))`

### 2.2. Using *toInt()* Method

Alternatively, **we can use the ***toInt()* method from the *String* class to parse the *octal* value as an integer value:

```
fun octalToDecimalUsingToInt(octal: String): Int {
return octal.toInt(8)
}
```

We call the *toInt()* method with a radix value of *8* to use the octal numeral system for parsing the *octal* string.

Now, let’s confirm that the *octalToDecimalUsingToInt()* method works as expected:

`Assertions.assertEquals(28, octalToDecimalUsingToInt("34"))`

### 2.3. Using *String* Extension Function

Let’s see how **we can write the ***octalToDecimal()* extension function for the *String* class:

```
fun String.octalToDecimal(): Int {
return Integer.parseInt(this, 8)
}
```

Now, let’s check that we get the desired results:

`Assertions.assertEquals("34", 28.decimalToOctal())`

That’s it! This approach adds convenience along with the core functionality.

### 2.4. Using *BigInteger*

When we have large values for conversion, we can use the *BigInteger* class.

Let’s **first create a ***BigInteger* value from the *octal* string and then get a decimal value as a result:

```
fun octalToDecimalUsingBigInteger(octal: String): Int {
val bigInt = BigInteger(octal, 8)
return bigInt.toInt()
}
```

It’s always recommended to verify our approach with a simple test:

`Assertions.assertEquals(28, octalToDecimalUsingBigInteger("34"))`

It looks good!

### 2.5. Using Iteration

Let’s see how we can iterate over each character of the *octal* value and compute the equivalent decimal value:

```
fun octalToDecimalUsingIteration(octal: String): Int {
var decimal = 0
var power = 0
for (position in octal.length - 1 downTo 0) {
val digit = octal[position].toString().toInt()
decimal += digit * Math.pow(8.0, power.toDouble()).toInt()
power++
}
return decimal
}
```

It’s important to note that **we parse the string from right to left and calculate its place value as ***digit**8^*position*. Further, we add this to the resultant *decimal* value in each iteration.

Additionally, let’s verify that our method is working correctly:

`Assertions.assertEquals(28, octalToDecimalUsingIteration("34"))`

## 3. Decimal to Octal Conversion

In this section, let’s learn how to convert decimal to octal values.

### 3.1. Using *Integer.toString()* Method

Let’s start by writing the *decimalToOctalUsingIntegerToString()* method for converting *decimal* to octal value:

```
fun decimalToOctalUsingIntegerToString(decimal: Int): String {
return Integer.toString(decimal, 8)
}
```

We use the *toString()* method internally and pass the radix value as *8*.

Additionally, let’s check the outcome for a sample value:

`Assertions.assertEquals("34", decimalToOctalUsingIntegerToString(28))`

Great! It looks like we’ve got this one right.

### 3.2. Using String Interpolation

Alternatively, we can **use string interpolation with the ***%0* format string to convert *decimal* value to a base-8 string:

```
fun decimalToOctalUsingStringInterpolation(decimal: Int): String {
return "%o".format(decimal)
}
```

Now, let’s confirm that we get the correct result with our approach:

`Assertions.assertEquals("34", decimalToOctalUsingStringInterpolation(28))`

### 3.3. Using *Int* Extension Function

We can also **extend the ***Int* class with the *decimalToOctal()* extension function:

```
fun Int.decimalToOctal(): String {
return Integer.toString(this, 8)
}
```

Next, let’s call the *decimalToOctal()* function for an *Int* value:

`Assertions.assertEquals("34", 28.decimalToOctal())`

### 3.4. Using Iteration

Lastly, let’s see how we can use iteration to convert a decimal value to its *octal* representation:

```
fun decimalToOctalUsingIteration(decimal: Int): String {
var octal = ""
var num = decimal
while (num > 0) {
octal = (num % 8).toString() + octal
num /= 8
}
return octal
}
```

We **repeatedly divide the original ***decimal* value by *8 *and note the remainder in the reverse order.

Furthermore, let’s verify the result works as expected:

`Assertions.assertEquals("34", decimalToOctalUsingIteration(28))`

## 4. Conclusion

In this article, **we learned multiple techniques for converting decimal values to octal values and vice-versa.**

As always, the code from this article is available over on GitHub.