这里有一个分而治之的解决方案。

如果自然数（数字）的平方根是自然数（解），您可以根据数字的位数轻松确定解的范围：

数字有1位：范围内的解=1-4数字有2位数：范围内的解=3-10数字有3位数：范围内的解=10-40数字有4位数字：范围=30-100数字有5位数：范围内的解=100-400

注意到重复了吗？

您可以在二进制搜索方法中使用此范围，以查看是否存在以下解决方案：

number == solution * solution

这是密码

这是我的类SquareRootChecker

public class SquareRootChecker {

    private long number;
    private long initialLow;
    private long initialHigh;

    public SquareRootChecker(long number) {
        this.number = number;

        initialLow = 1;
        initialHigh = 4;
        if (Long.toString(number).length() % 2 == 0) {
            initialLow = 3;
            initialHigh = 10;
        }
        for (long i = 0; i < Long.toString(number).length() / 2; i++) {
            initialLow *= 10;
            initialHigh *= 10;
        }
        if (Long.toString(number).length() % 2 == 0) {
            initialLow /= 10;
            initialHigh /=10;
        }
    }

    public boolean checkSquareRoot() {
        return findSquareRoot(initialLow, initialHigh, number);
    }

    private boolean findSquareRoot(long low, long high, long number) {
        long check = low + (high - low) / 2;
        if (high >= low) {
            if (number == check * check) {
                return true;
            }
            else if (number < check * check) {
                high = check - 1;
                return findSquareRoot(low, high, number);
            }
            else  {
                low = check + 1;
                return findSquareRoot(low, high, number);
            }
        }
        return false;
    }

}

下面是一个如何使用它的示例。

long number =  1234567;
long square = number * number;
SquareRootChecker squareRootChecker = new SquareRootChecker(square);
System.out.println(square + ": " + squareRootChecker.checkSquareRoot()); //Prints "1524155677489: true"

long notSquare = square + 1;
squareRootChecker = new SquareRootChecker(notSquare);
System.out.println(notSquare + ": " + squareRootChecker.checkSquareRoot()); //Prints "1524155677490: false"

标签中提到了项目Euler，其中的许多问题需要检查数字>>2^64。当您使用80字节缓冲区时，上面提到的大多数优化都不容易工作。

我使用了javaBigInteger和稍微修改过的Newton方法，它对整数更有效。问题是，精确的平方n^2收敛到（n-1）而不是n，因为n^2-1=（n-1）（n+1），最终误差仅比最终除数低一步，算法终止。在计算错误之前，通过在原始参数中添加一个参数很容易解决。（为立方体根等添加两个）

这个算法的一个优点是，你可以立即判断出这个数字是否是一个完美的平方-牛顿方法中的最终误差（不是校正）将为零。一个简单的修改也可以让您快速计算floor（sqrt（x）），而不是最接近的整数。这对于几个Euler问题很方便。

我参加聚会已经很晚了，但我希望能提供一个更好的答案；更短，（假设我的基准是正确的）也更快。

long goodMask; // 0xC840C04048404040 computed below
{
    for (int i=0; i<64; ++i) goodMask |= Long.MIN_VALUE >>> (i*i);
}

public boolean isSquare(long x) {
    // This tests if the 6 least significant bits are right.
    // Moving the to be tested bit to the highest position saves us masking.
    if (goodMask << x >= 0) return false;
    final int numberOfTrailingZeros = Long.numberOfTrailingZeros(x);
    // Each square ends with an even number of zeros.
    if ((numberOfTrailingZeros & 1) != 0) return false;
    x >>= numberOfTrailingZeros;
    // Now x is either 0 or odd.
    // In binary each odd square ends with 001.
    // Postpone the sign test until now; handle zero in the branch.
    if ((x&7) != 1 | x <= 0) return x == 0;
    // Do it in the classical way.
    // The correctness is not trivial as the conversion from long to double is lossy!
    final long tst = (long) Math.sqrt(x);
    return tst * tst == x;
}

第一个测试很快捕捉到大多数非正方形。它使用一个长的64项表，因此没有数组访问成本（间接和边界检查）。对于均匀随机的长，有81.25%的概率在这里结束。

第二个测试捕获因式分解中奇数为2的所有数字。Long.numberOfTrailingZeros方法非常快，因为它被JIT编译成一条i86指令。

删除尾随零后，第三个测试处理以二进制形式的011、101或111结尾的数字，这些数字不是完美的正方形。它还关心负数，也处理0。

最后的测试是双倍算术。由于double只有53位尾数，从long到double的转换包括大值的舍入。尽管如此，测试是正确的（除非证明是错误的）。

试图结合mod255的想法并不成功。

有人指出，完美正方形的最后d位只能取某些值。数字n的最后d位（以b为基数）与n除以bd时的余数相同，即C符号n%pow（b，d）。

这可以推广到任何模数m，即n%m可以用来排除某些百分比的数字是完全平方。您当前使用的模数是64，这允许12，即19%的余数作为可能的平方。通过一点编码，我找到了模数110880，它只允许2016，即1.8%的余数作为可能的平方。因此，根据模数运算（即除法）和查找表与机器上的平方根的成本，使用这个模数可能会更快。

顺便说一句，如果Java有办法为查找表存储一个压缩的位数组，那么不要使用它。现在110880个32位字的RAM不多，提取一个机器字将比提取一个位更快。

一个数字的平方根，假设该数字是一个完全平方。

复杂性为log（n）

/**
 * Calculate square root if the given number is a perfect square.
 * 
 * Approach: Sum of n odd numbers is equals to the square root of n*n, given 
 * that n is a perfect square.
 *
 * @param number
 * @return squareRoot
 */

public static int calculateSquareRoot(int number) {

    int sum=1;
    int count =1;
    int squareRoot=1;
    while(sum<number) {
        count+=2;
        sum+=count;
        squareRoot++;
    }
    return squareRoot;
}

maartinus解决方案的以下简化似乎使运行时减少了几个百分点，但我在基准测试方面做得不够好，无法产生我可以信任的基准：

long goodMask; // 0xC840C04048404040 computed below
{
    for (int i=0; i<64; ++i) goodMask |= Long.MIN_VALUE >>> (i*i);
}

public boolean isSquare(long x) {
    // This tests if the 6 least significant bits are right.
    // Moving the to be tested bit to the highest position saves us masking.
    if (goodMask << x >= 0) return false;
    // Remove an even number of trailing zeros, leaving at most one.
    x >>= (Long.numberOfTrailingZeros(x) & (-2);
    // Repeat the test on the 6 least significant remaining bits.
    if (goodMask << x >= 0 | x <= 0) return x == 0;
    // Do it in the classical way.
    // The correctness is not trivial as the conversion from long to double is lossy!
    final long tst = (long) Math.sqrt(x);
    return tst * tst == x;
}

值得检查的是，如何省略第一次测试，

if (goodMask << x >= 0) return false;

会影响性能。