Check Cube Number in Java

Beginner
⏱️ 9 min read
📚 Updated: May 2026
🎯 2 Code Examples
Number theory

What you’ll learn

  • What it means for an integer to be a perfect cube (n = k3).
  • A compact check using Math.cbrt and Math.round (with a final integer cube test), plus an all-integer loop like the range sample.
  • Sign, zero, overflow, and floating-point caveats, plus a browser live preview.

Overview

Given an integer n, decide whether n = k3 for some integer k. The reference idea uses the real cube root from Math.cbrt; we round it correctly, then verify with integer cubing.

Two programs

Math.cbrt + Math.round for a single value, then a linear k scan for the 1–50 listing.

Live preview

Try integers in the safe JS range; uses integer cube detection (no floating-point cube root in the browser).

Fixes vs naive round

Avoid (int)(Math.cbrt(n) + 0.5) on negatives; use Math.round and always confirm with an integer cube check.

Prerequisites

public static void main(String[] args), integer multiplication, and (for Example 1) Math.cbrt / Math.round.

  • Comfort with loops and if statements in Java.
  • Optional: why we widen to long when computing k * k * k.

What is a perfect cube?

An integer n is a perfect cube (cube number) if n = k3 for some integer k. That includes 0 = 03 and negative examples such as -8 = (-2)3.

Do not confuse “cube number” with “multiple of 3” or “square”; the operation is cubing, not squaring.

8 2³
27 3³
9 not a cube

Cube root characterization

For real x, the equation k3 = x has a unique real cube root k. For integer n, n is a perfect cube iff that real root is an integer—equivalently some rounded float estimate k satisfies k3 = n once checked in exact integer arithmetic.

n = 27

Real cube root of 27 is 3, and 33 = 27.

Intuition

27 3³
Check
3·3·3
28 Not a cube
Near
between 33 and 43

Takeaway: perfect cubes grow quickly in gaps: 1, 8, 27, 64, …

Live preview

JavaScript safe integers. Integer cube test: adjust sign for nonzero n, grow k until k3 ≥ |n|, then compare.

Try -8, 0, or a non-cube such as 28.

Live result
Press “Check cube” to classify the number.

Algorithm

Goal: return true iff n = k3 for some integer k.

Floating route

Compute k = Math.round(Math.cbrt(n)) as a long or int, then verify k*k*k == n using a wide enough type.

Integer route

For nonnegative n, increment k from 0 until k3 ≥ n; answer true iff equality.

📜 Pseudocode

Pseudocode (nonnegative integer route)
function isPerfectCubeNonneg(n):  // n ≥ 0
    k ← 0
    while k * k * k < n:
        k ← k + 1
    return k * k * k = n
1

Math.cbrt + Math.round + integer check

Uses Java’s Math.cbrt. Math.round fixes the naive (int)(Math.cbrt(n)+0.5) bug on negative cubes such as -27. Cubes are evaluated in long to reduce overflow risk for borderline int values.

java
public class Main {

    static boolean isCube(int number) {
        long k = Math.round(Math.cbrt(number));
        long c = k * k * k;
        return c == number;
    }

    public static void main(String[] args) {
        int inputNumber = 27;

        if (isCube(inputNumber)) {
            System.out.println(inputNumber + " is a cube number.");
        } else {
            System.out.println(inputNumber + " is not a cube number.");
        }
    }
}

Explanation

Math.cbrt returns a double. Rounding to the nearest integer and then cubing in long lets us check the result exactly for typical int ranges.

long c = k * k * k;

Verify in integers. Confirms the rounded root truly cubes back to number.

2

Integer scan: cubes from 1 to 50

Same output as the reference: 1 8 27. Uses nonnegative k only; for larger num you would keep the cube in long.

java
public class Main {

    static boolean isCubeNumber(int num) {
        int k = 0;

        while ((long) k * k * k < (long) num) {
            k++;
        }

        return (long) k * k * k == (long) num;
    }

    public static void main(String[] args) {
        System.out.println("Cube numbers in the range 1 to 50:");

        for (int i = 1; i <= 50; i++) {
            if (isCubeNumber(i)) {
                System.out.print(i + " ");
            }
        }

        System.out.println();
    }
}

Explanation

The loop finds the smallest k with k3 ≥ num. If num is a perfect cube, equality holds; otherwise k3 overshoots.

(long) k * k * k

Widen before multiply so intermediate products stay defined for larger inputs.

Optimization

Binary search on k. For huge nonnegative n, binary-search k in [0, n] (or a tighter upper bound) instead of stepping by one.

No floating-point. You can skip Math.cbrt entirely by using only integer search plus a cube check.

Interview: mention sign, 0, overflow, and why you verify k3 in integers after any float step.

❓ FAQ

An integer n is a perfect cube if n = k^3 for some integer k. Examples: 0 = 0^3, 1 = 1^3, 8 = 2^3, 27 = 3^3, -8 = (-2)^3.
Adding 0.5 before casting to int assumes rounding toward minus infinity; Java truncates toward zero. That can misclassify negative cubes. Use Math.round(cubeRoot) or cast from a long result, and always re-check with integer arithmetic.
In theory yes near very large integers; for int-sized values, pairing Math.cbrt with Math.round and then checking k*k*k == n in integer arithmetic is reliable in practice. For maximal safety across a wider range, use only integer arithmetic with long.
For large n, k^3 can exceed int before you compare. In Java, compute k * k * k in a long and compare against n promoted to long, or restrict to safe ranges.
Yes: 0 = 0^3. The programs on this page treat 0 as a perfect cube.
Increasing k until k^3 >= |n| runs in O(|n|^{1/3}) iterations for nonnegative n; each step is O(1) with long for the cube.

🔄 Input / output examples

Swap inputNumber in Example 1 or extend the loop in Example 2.

nPerfect cube?k
27Yes3
-8Yes-2
28No—
0Yes0

Edge cases and pitfalls

Rounding cube roots in floating point without a final integer check is fragile; naive +0.5 truncation is wrong for several negative values.

Sign

Math.cbrt on negatives

Math.cbrt is defined for negative reals. Pair it with Math.round, not biased-half truncation via + 0.5 and a cast.

Zero

n = 0

Perfect cube: 03. The integer loop must start at k = 0 for nonnegative num.

Overflow

k * k * k in int

For large k, the product can overflow int before comparison. Cast or store in long.

Double

Huge integers

IEEE double cannot represent all integers past 253 exactly; stick to integer methods for big integers.

⏱️ Time and space complexity

MethodTimeExtra space
Math.cbrt + verifyO(1) typical library costO(1)
Linear k scan (nonnegative)O(n1/3) iterationsO(1)
Binary search on kO(log n) iterationsO(1)

Here n denotes the magnitude of the input for the scan bound k ≈ n1/3.

Summary

  • Definition: n = k3 for some integer k (includes 0 and negatives).
  • Code: Math.round(Math.cbrt(n)) then cube-check, or pure integer increment / binary search.
  • Watch-outs: negative rounding, overflow in k3, and double precision limits.
Did you know?

A nonzero integer n is a perfect cube iff in its prime factorization every exponent is a multiple of three. The cube roots of 0 and 1 are 0 and 1 themselves.

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 Condense a Number Java Program to Convert Decimal to Binary