Convert Decimal to Octal in Java

Beginner
⏱️ 9 min read
📚 Updated: May 2026
🎯 2 Code Examples
Base conversion

What you’ll learn

  • How division by eight and remainders produce octal digits 0–7.
  • Why zero needs a branch and why digits are printed in reverse of collection order.
  • A recursive MSB-first print without an array, a live preview, and ties to binary grouping.

Overview

Octal is base eight. To print a nonnegative decimal integer in octal, repeatedly take n % 8, then replace n by n / 8, until n is zero; emit the remainders from last to first.

Two programs

Array + reverse print (classic), then recursion for MSB-first output.

Live preview

Nonnegative safe integers via Number#toString(8).

Pair with binary

Same remainder pattern as decimal-to-binary, divisor 8 instead of 2.

Prerequisites

Integer division and modulo, arrays, for and while loops, optional recursion.

  • Java basics: methods, loops, and printing with System.out.
  • Understanding that integer division in Java discards the fractional part.

Decimal to octal

Each octal digit is a coefficient on a power of eight: dk8k + ... + d080 with every di in {0,...,7}. The peel operation n % 8 reads the least significant octal digit.

Reference value 57: 57 = 7*8 + 1, so octal digits (MSB to LSB) are 7 then 1 -> 718.

Decimal base 10
Octal base 8
Digits 0 - 7

Division algorithm

For n >= 0, let d0 = n mod 8 and n1 = floor(n/8), then repeat. The sequence of remainders read from last generated to first is the standard octal numeral for n.

57

57 = 8*7 + 1, then 7 = 8*0 + 7. Remainders LSB-first: 1, 7 -> octal 71.

Intuition

64 100 (oct)
Power
82
57 71 (oct)
Sum
7*8 + 1

Takeaway: each % 8 answers which slice of eight fits in the current place.

Live preview

Nonnegative integers in the JavaScript safe range. Uses Number#toString(8).

Negative values are rejected here; two's complement formatting is a different convention.

Live result
Press “Show octal” to convert.

Algorithm (remainder method)

Goal: print octal digits of nonnegative n in MSB-first order.

Special case n == 0

Print 0 when n is zero; while (n != 0) alone skips the body.

Collect digits

While n > 0: push n % 8, then n /= 8.

Print reversed

Emit stored digits from last pushed to first.

📜 Pseudocode

Pseudocode
function printOctalFromDecimal(n):  // n >= 0
    if n = 0:
        output "0"; return
    digits <- empty list
    while n > 0:
        append (n mod 8) to digits
        n <- floor(n / 8)
    print digits in reverse order
1

Divide by eight with reverse print

Matches the reference flow with a zero branch. Uses a small digit buffer (more than enough for 32-bit int values).

java
public class Main {

    static String decimalToOctal(int decimalNumber) {
        if (decimalNumber == 0) {
            return "0";
        }

        int[] octalDigits = new int[16];
        int i = 0;
        int n = decimalNumber;

        while (n != 0) {
            octalDigits[i] = n % 8;
            n /= 8;
            i++;
        }

        StringBuilder sb = new StringBuilder(i);
        for (int j = i - 1; j >= 0; j--) {
            sb.append(octalDigits[j]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        int decimalNumber = 57;

        System.out.println("Octal equivalent: " + decimalToOctal(decimalNumber));
        System.out.println("Octal equivalent: " + decimalToOctal(0));
    }
}

Explanation

Each remainder is in 0..7 by construction, so a single decimal digit per position is enough for display.

while (n != 0)

Same stopping test as the reference, paired with an upfront 0 print.

2

Recursive MSB-first (no digit array)

Prints higher groups before lower ones: recurse on n/8, then append n%8. Handles n == 0 in the wrapper.

java
public class Main {

    static void buildOctalRecursive(int n, StringBuilder out) {
        if (n >= 8) {
            buildOctalRecursive(n / 8, out);
        }
        out.append(n % 8);
    }

    static String toOctalRecursive(int n) {
        if (n == 0) {
            return "0";
        }
        StringBuilder out = new StringBuilder();
        buildOctalRecursive(n, out);
        return out.toString();
    }

    public static void main(String[] args) {
        System.out.println("57 in octal: " + toOctalRecursive(57));
        System.out.println("0 in octal: " + toOctalRecursive(0));
    }
}

Explanation

The recursion depth equals the number of octal digits; for 32-bit ints that is small in practice.

out.append(n % 8);

Single octal digit. In base 8 each place is always 0 to 7.

Optimization and library path

Integer.toOctalString(n). Prints octal without manual loops once you accept library formatting rules.

From binary. Group bits in threes from the right to jump between bases without repeated division by eight.

Interview: state nonnegative assumption, n==0, and the 3-bit grouping trick.

❓ FAQ

Octal is base 8. The remainder n % 8 is the least significant octal digit; integer division n/8 removes that digit, just like decimal to binary uses 2.
The first remainder is the rightmost (least significant) octal digit. Printing from last remainder to first yields MSB-to-LSB order.
while (n != 0) never runs, so you must print 0 explicitly; otherwise you only print the label and a blank line.
Yes: Integer.toOctalString(n) or Long.toOctalString(n) prints octal quickly once you understand the manual algorithm.
One octal digit encodes exactly three bits. Converting binary to octal groups bits in threes from the radix point outward.
O(log8 n) = O(log n) octal digits for nonnegative n using the remainder method; the recursive print does one call per digit.

🔄 Input / output examples

Example 1 uses 57 and 0; Example 2 repeats 57 and 0 with the recursive printer.

DecimalOctal
00
77
810
5771
64100

Edge cases and pitfalls

Signed negatives with truncating division do not give a clean positive-octal string without an explicit policy.

Zero

n == 0

The loop while (n != 0) skips the body; always print 0 explicitly.

Digits

Remainder range

For nonnegative n, n % 8 is always in 0..7. If you ever see 8 or 9, the logic is wrong.

Recursion

Very wide integers

For arbitrary-precision values, prefer an iterative loop or explicit stack to avoid deep recursion.

Literal syntax

Leading zero confusion

In Java source, octal integer literals start with a leading zero (like 071), but string output "71" is just text.

⏱️ Time and space complexity

ApproachTimeExtra space
Remainder + arrayO(log8 n) digitsO(log8 n) stored digits
Recursion (Example 2)O(log8 n)O(log8 n) call frames
Integer.toOctalStringImplementation-defined; typically O(d)O(1) extra

Here n is the magnitude of a nonnegative input.

Summary

  • Idea: collect n % 8, divide n by 8, reverse for display.
  • Code: guard 0; be explicit about negative-number policy.
  • Extra: octal lines up with binary in groups of three bits.
Did you know?

Each octal digit corresponds to a block of three binary bits, which is why Unix file modes and some literals are still written in base eight.

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

8 people found this page helpful

Java Program to Convert Decimal to Binary Java Program to Check Disarium Number