How to Check if a long Is a Perfect Square in Java

By the end of this page, you will understand how to check whether a long is a perfect square in Java, why Math.sqrt() is usually the best baseline, how integer-based filtering can speed things up, and what common correctness and overflow issues to avoid.

A perfect square is a number that can be written as k * k for some integer k.

Examples:

• 0 = 0 * 0
• 1 = 1 * 1
• 4 = 2 * 2
• 9 = 3 * 3
• 16 = 4 * 4

For a Java long, the task is:

1. Reject negative numbers immediately.
2. Compute a candidate square root.
3. Check whether squaring that candidate gives the original number.

The most common practical solution is:

long root = (long) Math.sqrt(n);
return root * root == n;

Sometimes people round instead of truncating:

long root = (long) (Math.sqrt(n) + 0.5);
return root * root == n;

Why this matters:

Think of this as a two-stage security check:

1. Front desk screening: quickly reject values that could never be perfect squares.
2. Identity verification: compute the square root candidate and confirm it exactly.

For example, many numbers can be rejected just by looking at their last few bits. A square number cannot end with every possible bit pattern.

So instead of asking every number to go through the expensive full check, you first ask:

• “Do you even look like a square?”

If the answer is no, return false immediately.

If yes, then do the more expensive exact verification using Math.sqrt() and multiplication.

This is a common performance pattern in programming:

• cheap filter first
• expensive exact check second

The simplest correct Java approach is:

public static boolean isPerfectSquare(long n) {
    if (n < 0) {
        return false;
    }

    long root = (long) Math.sqrt(n);
    return root * root == n;
}

How it works

• Math.sqrt(n) returns a double
• Casting to long removes the decimal part
• If n is a perfect square, then root * root == n

Example

System.out.println(isPerfectSquare(16)); // true
System.out.println(isPerfectSquare(15)); // false
System.out.println(isPerfectSquare(0));  // true
System.out.println(isPerfectSquare(-4)); // false

Adding a fast pre-check

Consider this version:

public static boolean isPerfectSquare(long n) {
    if (n < 0) {
        return false;
    }

    long root = (long) Math.sqrt(n);
    return root * root == n;
}

Now trace it with n = 81.

Step 1

if (n < 0)

• 81 < 0 is false
• continue

Step 2

long root = (long) Math.sqrt(n);

• Math.sqrt(81) gives 9.0
• cast to long gives

Perfect square checks are more common than they first appear.

Number theory and coding challenges

• Project Euler problems
• prime-related formulas
• integer sequence generation
• factor pair detection

Geometry and grids

• checking whether an area can form an exact square
• verifying square dimensions in tile or board problems
• detecting integer distances in coordinate problems

Data processing

• validating that a value matches square-based constraints
• checking matrix sizes such as n x n
• converting a flat array length into a square grid

Example:

int cells = 144;
if (isPerfectSquare(cells)) {
    int size = (int) Math.sqrt(cells);
    System.out.println("Grid is " + size + " x " + size);
}

Game and simulation logic

• square map generation
• board sizing
• validating player-built structures

Performance-sensitive filters

In math-heavy programs, a square test is often used as a gate before doing more expensive work.

In real projects, developers usually combine this concept with a few common patterns.

1. Guard clauses

Reject impossible cases early:

if (n < 0) {
    return false;
}

This keeps the function simple and avoids nested logic.

2. Cheap pre-validation

Use modular or bitwise checks before expensive operations:

int last = (int) (n & 0xF);
if (last != 0 && last != 1 && last != 4 && last != 9) {
    return false;
}

This is common in high-throughput code where most inputs fail.

3. Exact verification after approximation

Even if the root comes from floating-point math, the final test should be exact:

long root = (long) Math.sqrt(n);
return root * root == n;

This pattern appears in many algorithms:

• estimate first

1. Forgetting negative inputs

Broken code:

public static boolean isPerfectSquare(long n) {
    long root = (long) Math.sqrt(n);
    return root * root == n;
}

Problem:

• Math.sqrt() of a negative number is NaN
• casting NaN to long does not express your intent clearly

Better:

if (n < 0) {
    return false;
}

2. Trusting floating-point without exact verification

Broken code:

return Math.sqrt(n) % 1 == 0;

Problem:

• floating-point values can have rounding issues
• equality checks on floating-point results are risky

Basic perfect square check

public static boolean isPerfectSquare(long n) {
    if (n < 0) return false;
    long root = (long) Math.sqrt(n);
    return root * root == n;
}

Fast reject using last hex digit

int last = (int) (n & 0xF);
if (last != 0 && last != 1 && last != 4 && last != 9) {
    return false;
}

Important rules

• Negative numbers are not perfect squares in the integer domain.
• Always do an exact final check: root * root == n.
• Do not rely on Math.sqrt(n) % 1 == 0.
• Math.sqrt() is usually the best baseline in Java.
• Pre-filters help when most inputs are non-squares.

Common valid endings for squares

Is Math.sqrt() accurate enough for checking perfect squares in Java?

Yes, when you use it only to get a candidate root and then verify with root * root == n.

Do I need to add 0.5 before casting?

Usually no for this pattern. A truncation-based check is commonly sufficient when followed by exact verification.

Why not use Math.sqrt(n) % 1 == 0?

Because floating-point values can have rounding behavior that makes exact decimal-based checks unreliable.

Is there a faster integer-only algorithm than Math.sqrt()?

Sometimes in theory, but in Java Math.sqrt() is often faster in practice because it is highly optimized and may use hardware instructions.

Why does a bitwise pre-check help?

It quickly rejects values that cannot be squares, so you avoid many square root calls.

Can root * root overflow?

With the common pattern using root = (long) Math.sqrt(n), the root is at most about 3037000499, so root * root stays within long range.

Should I use a lookup array for the modular filter?

• Math.sqrt in Java — the standard way to compute square roots.
• Type casting — needed when converting the double result of Math.sqrt() to long.
• Floating-point precision — explains why approximate values should be verified exactly.
• Overflow — important when multiplying integers in custom square root algorithms.
• Bitwise operations — useful for fast modular checks such as n & 0xF.
• Guard clauses — help reject invalid inputs early and keep code simple.
• Benchmarking — essential when comparing micro-optimizations in performance-sensitive code.
• Binary search — a possible but usually slower way to compute integer square roots.
• Newton's method — an alternative root-finding technique that is often more complex in Java for this use case.