第一种方法

public class TestClosest2NthPower {

public static void main(String[] args) {
System.out.println(test(-1));//1
System.out.println(test(1));//1
System.out.println(test(-1));//1
System.out.println(test(10));//16
System.out.println(test(16));//16
System.out.println(test(Integer.MAX_VALUE));//2^30
  }

private static int test(int target) {
//int类型最大值为(2^31)-1，所以目标能取到的最大值为2^30
int MAXIMUM = 1 << 30;
if (target >= MAXIMUM) {
return MAXIMUM;
    }
int result = 1;
while (result < target) {
result *= 2;
    }
return result;
  }

}


相当于在2的0次幂和2的30次幂中的31个数中找一个最接近的数。

[2^0,2^1 ... 2^30]


第二种方法

public class TestClosest2NthPower2 {

public static void main(String[] args) {
System.out.println(test(-1));//1
System.out.println(test(1));//1
System.out.println(test(-1));//1
System.out.println(test(10));//16
System.out.println(test(16));//16
System.out.println(test(Integer.MAX_VALUE));//2^30
  }

private static int test(int target) {
//int类型最大值为(2^31)-1，所以目标能取到的最大值为2^30
int MAXIMUM = 1 << 30;
if (target >= MAXIMUM) {
return MAXIMUM;
    }
int temp = target - 1;
temp |= temp >> 1;
temp |= temp >> 2;
temp |= temp >> 4;
temp |= temp >> 8;
temp |= temp >> 16;
return (temp < 0) ? 1 : temp + 1;
  }

}


示例分析

以129为例(可以更明显看出效果)，先减1为128，二进制表示为

00000000 00000000 00000000 10000000


右移1位

00000000 00000000 00000000 01000000


两者按位或

00000000 00000000 00000000 11000000


保证了前两位都为1，以此类推可以保证第一个1及之后的所有位都为1

00000000 00000000 00000000 11111111


再加一

00000000 00000000 00000001 00000000


十进制表示为256。

核心原理

核心原理就是将一个数减1的二进制表示的第一个1及之后的所有位都置为1，然后加1，这样得到的数就是2的N次幂，相当于最高位的1向左进1位，之后的所有位都置为0。

为什么要先减1

为了兼容一个数已经是2的N次幂的情况。以2的4次幂16为例，减1为15，最后操作结果还是16，如果这个数不是2的N次幂，如15，其实减不减1都可以得到正确结果16。

使用场景

ForkJoinPool的构造器中初始化workQueues的容量时就使用到了这种方法。

第三种方法

public class TestClosest2NthPower3 {

public static void main(String[] args) {
System.out.println(test(-1));//1
System.out.println(test(1));//1
System.out.println(test(-1));//1
System.out.println(test(10));//16
System.out.println(test(16));//16
System.out.println(test(Integer.MAX_VALUE));//2^30
  }

private static int test(int target) {
//int类型最大值(2^31)-1，所以目标能取到的最大值为2^30
int MAXIMUM = 1 << 30;
if (target >= MAXIMUM) {
return MAXIMUM;
    }
int n = -1 >>> Integer.numberOfLeadingZeros(target - 1);
return (n < 0) ? 1 : n + 1;
  }

}


示例分析

以129为例(可以更明显看出效果)，先减1为128，二进制表示为

00000000 00000000 00000000 10000000


使用Integer的numberOfLeadingZeros()方法求出前导0的个数为24，-1的二进制表示为

11111111 11111111 11111111 11111111


无符号右移24位

00000000 00000000 00000000 11111111


再加一

00000000 00000000 00000001 00000000


十进制表示为256。

核心原理

和上一个方法的原理类似，也是将一个数减1的二进制表示的第一个1及之后的所有位都置为1，然后加1。

使用场景

这种方法参考的就是HashMap中计算容量大小的算法。