Program to Calculate Square Root in Java

Calculating square roots is a fundamental mathematical operation that appears in many programming problems. In Java, you can calculate square roots using built-in methods or by implementing your own algorithm. This guide provides complete examples of how to write Java programs to calculate square roots, including handling user input and edge cases.

Basic Java Program to Calculate Square Root

The simplest way to calculate a square root in Java is to use the Math.sqrt() method from the Java standard library. This method takes a double value and returns its square root as a double.

Formula

The square root of a number x is a value that, when multiplied by itself, gives x. Mathematically, this is represented as:

√x = y where y × y = x

Here's a basic Java program that calculates the square root of a number:

public class SquareRoot {
    public static void main(String[] args) {
        double number = 25.0;
        double squareRoot = Math.sqrt(number);
        System.out.println("Square root of " + number + " is: " + squareRoot);
    }
}

When you run this program, it will output:

Square root of 25.0 is: 5.0

This example uses a hardcoded value, but in real applications, you'll typically want to accept user input.

Using Java's Math Class

The Math class in Java provides several methods for mathematical operations, including square root calculation. The Math.sqrt() method is particularly useful for this purpose.

Key Points

The Math.sqrt() method returns a double value
It can calculate square roots of both positive and negative numbers
For negative numbers, it returns a special "Not a Number" value (NaN)
The method is part of the Java standard library, so no additional imports are needed

Here's an example that demonstrates different scenarios:

public class SquareRootExamples {
    public static void main(String[] args) {
        // Positive number
        double positive = 16.0;
        System.out.println("√" + positive + " = " + Math.sqrt(positive));

        // Negative number
        double negative = -9.0;
        System.out.println("√" + negative + " = " + Math.sqrt(negative));

        // Zero
        double zero = 0.0;
        System.out.println("√" + zero + " = " + Math.sqrt(zero));

        // Fraction
        double fraction = 0.25;
        System.out.println("√" + fraction + " = " + Math.sqrt(fraction));
    }
}

The output of this program will be:

√16.0 = 4.0
√-9.0 = NaN
√0.0 = 0.0
√0.25 = 0.5

Accepting User Input

In most practical applications, you'll want to accept user input for the number to calculate the square root of. Java provides several ways to handle user input, with Scanner being one of the most common.

Steps to Accept User Input

Import the java.util.Scanner class
Create a Scanner object to read from standard input
Prompt the user to enter a number
Read the input using the nextDouble() method
Calculate and display the square root

Here's a complete example that accepts user input:

import java.util.Scanner;

public class SquareRootInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a number to calculate its square root: ");
        double number = scanner.nextDouble();

        double squareRoot = Math.sqrt(number);

        System.out.println("The square root of " + number + " is: " + squareRoot);

        scanner.close();
    }
}

When you run this program, it will prompt you to enter a number and then display the square root:

Enter a number to calculate its square root: 36
The square root of 36.0 is: 6.0

Error Handling

When working with user input, it's important to handle potential errors. The most common issues when calculating square roots are:

Non-numeric input
Negative numbers (which return NaN)
Very large numbers that might cause overflow

Here's an enhanced version of the program with basic error handling:

import java.util.Scanner;
import java.util.InputMismatchException;

public class SquareRootWithErrorHandling {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        try {
            System.out.print("Enter a non-negative number to calculate its square root: ");
            double number = scanner.nextDouble();

            if (number < 0) {
                System.out.println("Error: Cannot calculate square root of a negative number.");
            } else {
                double squareRoot = Math.sqrt(number);
                System.out.println("The square root of " + number + " is: " + squareRoot);
            }
        } catch (InputMismatchException e) {
            System.out.println("Error: Please enter a valid number.");
        } finally {
            scanner.close();
        }
    }
}

This version includes:

Try-catch block to handle non-numeric input
Check for negative numbers
Proper resource cleanup with finally block

Complete Example Program

Here's a complete Java program that calculates square roots with all the features we've discussed:

import java.util.Scanner;
import java.util.InputMismatchException;

public class SquareRootCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Square Root Calculator");
        System.out.println("----------------------");

        try {
            System.out.print("Enter a non-negative number: ");
            double number = scanner.nextDouble();

            if (number < 0) {
                System.out.println("Error: Cannot calculate square root of a negative number.");
            } else {
                double squareRoot = Math.sqrt(number);
                System.out.printf("The square root of %.2f is: %.4f%n", number, squareRoot);

                // Additional information
                System.out.println("\nAdditional Information:");
                System.out.printf("Square of the square root: %.2f%n", squareRoot * squareRoot);
                System.out.printf("Square of the original number: %.2f%n", number * number);
            }
        } catch (InputMismatchException e) {
            System.out.println("Error: Please enter a valid number.");
        } finally {
            scanner.close();
        }
    }
}

This program includes:

User-friendly interface with clear instructions
Error handling for invalid input
Check for negative numbers
Formatted output with 4 decimal places
Additional information about the relationship between the number and its square root

Example output:

Square Root Calculator
----------------------
Enter a non-negative number: 49
The square root of 49.00 is: 7.0000

Additional Information:
Square of the square root: 49.00
Square of the original number: 2401.00

Frequently Asked Questions

How do I calculate the square root of a negative number in Java?: The Math.sqrt() method in Java returns NaN (Not a Number) for negative inputs. If you need to work with complex numbers, you would need to implement your own complex number class.
What is the difference between Math.sqrt() and Math.pow() for square roots?: Math.sqrt(x) is specifically designed to calculate square roots and is more efficient than Math.pow(x, 0.5). The Math.sqrt() method is preferred for square root calculations.
Can I calculate square roots of very large numbers in Java?: Yes, Java can handle very large numbers, but be aware of potential overflow issues. For extremely large numbers, you might need to use specialized libraries or algorithms.
How accurate are the square root calculations in Java?: Java uses IEEE 754 floating-point arithmetic, which provides approximately 15 decimal digits of precision for double values. The accuracy depends on the magnitude of the number being calculated.
Is there a way to calculate square roots without using the Math class?: Yes, you can implement your own square root algorithm using methods like the Newton-Raphson method or binary search. However, these implementations are generally less efficient than using the built-in Math.sqrt() method.