The cast technique is much better than it may seem to be at first sight.

Conversion from int to double is exact.

Math.sqrt is specified, for normal positive numbers, to return "the double value closest to the true mathematical square root of the argument value". If the input was a perfect square int, the result will be an integer-valued double that is in the int range.

Similarly, conversion of that integer-valued double back to an int is also exact.

The net effect is that the cast technique does not introduce any rounding error in your situation.

If your program would otherwise benefit from use of the Guava intMath API, you can use that to do the square root, but I would not add dependency on an API just to avoid the cast.

You have a couple of problems here:

1) Logical bug: 0 == 0 * 0

<= This means while (dummy != dummy * dummy) {..} will never be untrue, and you'll never even enter the loop

2) Floating point numbers are inexact, so your algorithm (which relies on "==") might not work anyway

Look here for more details on floating point imprecision:

http://www.lahey.com/float.htm

This is true for ANY language - your algorithm for square root must take this into account.

Duplicated logic

Avoid duplicated logic like this:

public static boolean closeEnough(double a, double x, double epsilon) {
    return (Math.abs(x - ((a / x) + x) / 2)) <= epsilon;
}

public static double betterGuess(double a, double x) {
    return ((a / x) + x) / 2;
}

The closeEnough method includes the exact same logic as betterGuess. Make it a habit to look at duplicated code fragments with suspicion.

If you eliminate the duplication, the code becomes:

public static boolean closeEnough(double a, double x, double epsilon) {
    return (Math.abs(x - betterGuess(a, x))) <= epsilon;
}

public static double betterGuess(double a, double x) {
    return ((a / x) + x) / 2;
}

... but then, does this actually make sense? Calling betterGuess from closeEnough? Not really. How can you check if a candidate square root is close enough? You cannot compare with the real square root, because that's the target unknown. What you can compare with, is the original number, which you should be able to get by squaring:

public static boolean closeEnough(double a, double x, double epsilon) {
    return Math.abs(a - x * x) <= epsilon;
}

This implementation is more logical, and has another positive side effect: it makes it possible to clean up the squareRoot method with the suspicious 0-check:

public static double squareRoot(final double a, final double epsilon) {
    if (a == 0)
        return a;
    else
        return internalSqrRoot(a, a / 2, epsilon);
}

The method can become simply:

public static double squareRoot(final double a, final double epsilon) {
    return internalSqrRoot(a, a / 2, epsilon);
}

It would seem the 0-check was there to prevent a division by zero problem in Math.abs(x - ((a / x) + x) / 2))

Method visibility

The MathUtil class name suggests it's a utility class, but the public MathUtil.betterGuess method (to name just one) doesn't seem very useful. It's an implementation detail that should be hidden, so make it private. Question the other methods too, and change their visibility as appropriate.

The variable names are quite poor. For example in closeEnough it's impossible to tell if the target number is a or x. target and candidate might have been better names.

Input validation

More than just commenting "Function takes a non-negative real number ", it would be better to enforce that by throwing an IllegalArgumentException.

Poor JavaDoc

This kind of JavaDoc is worse than no JavaDoc at all:

/**
 * Method internalSqrRoot.
 *
 * @param a double
 * @param x double
 * @param epsilon double
 * @return double
 */

It's worse, because tells nothing new about the method, but since it's there, I've read it, in vain.

Minor things

• It's recommended to use braces even with single-line if statements
• Redundant parentheses in the expression (Math.abs(x - ((a / x) + x) / 2))
• Perhaps instead of internalSqrRoot, squareRootHelper might be a better name. Or, since the method has a different signature than squareRoot, it can just as well be squareRoot (overloading)

Java program to find out square root of a given number without using any Built-In Functions

public class Sqrt
{

  public static void main(String[] args)
  {
    //Number for which square root is to be found
    double number = Double.parseDouble(args[0]);

    //This method finds out the square root
    findSquareRoot(number);

}

/*This method finds out the square root without using
any built-in functions and displays it */
public static void findSquareRoot(double number)
{

    boolean isPositiveNumber = true;
    double g1;

    //if the number given is a 0
    if(number==0)
    {
        System.out.println("Square root of "+number+" = "+0);
    }

    //If the number given is a -ve number
    else if(number<0)
    {  
        number=-number;
        isPositiveNumber = false;
    }

    //Proceeding to find out square root of the number
    double squareRoot = number/2;
    do
    {
        g1=squareRoot;
        squareRoot = (g1 + (number/g1))/2;
    }
    while((g1-squareRoot)!=0);

    //Displays square root in the case of a positive number
    if(isPositiveNumber)
    {
        System.out.println("Square roots of "+number+" are ");
        System.out.println("+"+squareRoot);
        System.out.println("-"+squareRoot);
    }
    //Displays square root in the case of a -ve number
    else
    {
        System.out.println("Square roots of -"+number+" are ");
        System.out.println("+"+squareRoot+" i");
        System.out.println("-"+squareRoot+" i");
    }

  }
}

Simply

System.out.println("Square Root: \u221A");

Source: first match on Google.