今天遇到问题需要计算以2为底的对数值（需要整数），找了半天API中log函数有自然对数，以10为底的对数，没有以2为底的，~~o(>_<)o ~~，API中提供的方法返回的都是double类型的，可能你会觉得，不就这么简单嘛，其实这里面学问也挺大的呢，且听我慢慢叙来~~

• 方法一：

            log[a]x log[b]x = ---------            log[a]b

            log[10]x log[2]x = ----------            log[10]2

1. static int pow(int base,int power){
2. int result =1;
3. for(int i =0; i < power; i++)
4. result *= base;
5. return result;
6. }
7. private static void test(int base,int pow){
8. int x = pow(base, pow);
9. if(pow != log(x, base))
10. System.out.println(String.format("error at %d^%d", base, pow));
11. if(pow!=0&&(pow-1)!= log(x-1, base))
12. System.out.println(String.format("error at %d^%d-1", base, pow));
13. }
14. static int log(int x,int base)
15. {
16. return(int)(Math.log(x)/Math.log(base));
17. }
18. public static void main(String[] args){
19. for(int base =2; base <500; base++){
20. int maxPow =(int)(Math.log(Integer.MAX_VALUE)/Math.log(base));
21. for(int pow =0; pow <= maxPow; pow++){
22. test(base, pow);
23. }
24. }
25. }

error at 3^5error at 3^10error at 3^13error at 3^15error at 3^17error at 9^5error at 10^3error at 10^6error at 10^9error at 11^7error at 12^7...

也就是说，当底为第一个数，指数为第二个数时，用(int)(Math.log(x)/Math.log(base))是有问题的，又有人提出用近似值（"epsilon"）来减小误差：(int)(Math.log(x)/Math.log(2)+1e-10)，这种方法也是可以的；

• 方法二：

1. public static int log2(int n){
2. if(n <=0)throw new IllegalArgumentException();
3. return31-Integer.numberOfLeadingZeros(n);
4. }

UPD: My integer arithmetic function is 10 times faster than Math.log(n)/Math.log(2).

• 方法三：

1. public static int log2X(int bits )// returns 0 for bits=0
2. {
3. int log =0;
4. if(( bits &0xffff0000)!=0){ bits >>>=16; log =16;}
5. if( bits >=256){ bits >>>=8; log +=8;}
6. if( bits >=16 ){ bits >>>=4; log +=4;}
7. if( bits >=4 ){ bits >>>=2; log +=2;}
8. return log +( bits >>>1);
9. }
10. //自己慢慢理解吧^_^

这种方法要比 Integer.numberOfLeadingZeros() 快上20-30%，要比一个如下所示的基于Math.log()
的 方法几乎快10 倍：

1. private static final double log2div =Math.log(2);
2. public static int log2fp(int bits )
3. {
4. if( bits ==0)
5. return0;// or throw exception
6. return(int)(Math.log( bits &0xffffffffL)/ log2div );
7. }

我说的没错吧，可能你觉得太钻牛角尖了，也是，不过别人能用更优雅，效率更高的方法实现相 同的功能，也
值得借鉴一下，并且以后在用浮点数代替整数计算时也要晓得，会不会有“陷阱”~~