num=num+"0";

}

return num;

}

算法1在输入为10的8次方(即1亿)时，用时1102毫秒。输入为10的9次方时，算法1就力不从心了，算了超过10秒还没有出来结果。

从算法上来看，主要的问题在于n往下减的速度太慢，每次都减1，其实n可以一步到位算出，优化后得到算法2：

/*

* 使用对撞指针,下限步长为1，上限一步到位

*/

public static int maxPrime2(int num) {

int i = num;

while (i > 1) {

int m = 2, n = i/m;

while (m

if (m * n == i) {

break;

} else if (m * n > i) {

n=i/m;

} else {

m++;

}

}

if (m > n) {

return i;

}

i--;

}

return 1;

}

算法2在输入为10的8次方时，用时1毫秒。输入为10的9次方时，用时也是1毫秒。输入为10的10次方时，超过了JAVA中int类型的上限，不能计算了。

于是修改算法2的输入类型，由int换成long，修改后得到算法3：

/*

* 使用对撞指针,下限步长为1，上限一步到位

*/

public static long maxPrime3(long num) {

long i = num;

while (i > 1) {

long m = 2, n = i/m;

while (m

if (m * n == i) {

break;

} else if (m * n > i) {

n=i/m;

} else {

m++;

}

}

if (m > n) {

return i;

}

i--;

}

return 1;

}

算法3在输入为10的10次方时，用时7毫秒。输入为10的15次方时，用时也是893毫秒。输入为10的16次方时，用时是5299毫秒，得到最大素数为9999999999999937。输入为10的17次方时，算了超过10秒还没有出来结果。

因为long还是有数值的限制，于是考虑换成没有限制的BigInteger，得到算法4：

/*

* 使用对撞指针,下限步长为1，上限一步到位

*/

public static BigInteger maxPrime4(BigInteger num) {

BigInteger i = num;

BigInteger num1 = new BigInteger("1");

while (i.compareTo( num1) > 0) {

BigInteger m = new BigInteger("2"), n = i.divide(m);

while (m.compareTo(n)

BigInteger i2=m.multiply( n);

if (i2.compareTo(i) == 0) {

break;

} else if (i2.compareTo(i)> 0) {

n=i.divide(m);

} else {

m=m.add(num1);

}

}

if (m.compareTo(n) > 0) {

return i;

}

i=i.subtract(num1);

}

return num1;

}算法4在输入为10的15次方时，用时8974毫秒。输入为10的16次方时，算了超过10秒还没有出来结果。由此可见BigInteger的计算消耗比long要大，优点是没有数据的上限的限制。

以上4种算法的效率对比如下：

另外也测了下指定上限算出全部素数的算法，代码如下：

/*

* 使用对撞指针,下限步长为1，上限一步到位

*/

public static long maxPrimeSet(long num) {

Setprimes=new HashSet();

Long maxPrime=2L;

primes.add(maxPrime);

for(long i=3;i

boolean isPrime=true;

for (long prime : primes) {

if(i/prime*prime==i) {

isPrime=false;

break;

}

}

if(isPrime) {

maxPrime=i;

primes.add(maxPrime);

}

}

System.out.println("素数个数："+primes.size());

return maxPrime;

}

结果最大输入为10的5次方(再增加超过10秒还没有结果)，输出如下：

素数个数：9592

最大素数: 99991

用时：2747毫秒

以上是关于最大索数计算的小探索，希望有兴趣的朋友可以帮看下上面的算法能否进一步优化，算出更大的结果。