JDK源码之Integer类—bitCount()方法

最新推荐文章于 2023-01-13 11:03:25 发布
最新推荐文章于 2023-01-13 11:03:25 发布
阅读量615 收藏 2
点赞数
分类专栏： # JDK源码 文章标签： Java JDK源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/117375334
版权

bitCount()方法的功能是计算一个int类型数值的二进制补码中"1"的出现个数。

例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17。

该方法的源码如下：

    /**
     * 返回指定int值的二进制补码二进制表示形式中的一位数
     * 即统计指定int值的二进制补码中1的出现次数
     * 例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
     *
     * @param i 要计数的值
     * @return 返回指定int值的二进制补码中1的出现次数
     */
    public static int bitCount(int i) {
        i = i - ((i >>> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        return i & 0x3f;
    }

要理解bitCount()方法的原理，那么需要慢慢来，先看看bitCount()方法的原型：

public static int bitCount(int i) {
    i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
    i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
    i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
    i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
    return i;
}

思路就是：不断二分来统计1个出现次数，并且用移位的方式来记录1的个数。

  • 例如，二进制00中高1位和低1位都是0，那么0+0也等于0，表示1的个数为00；
  • 例如，二进制11中高1位和低1位都是0，那么眼睛观察有两个1，1+1等于10（这是二进制的加法得出的结果），表示1的个数有两个即10；
  • 例如，二进制10中高1位和低1位分别为1和0，那么眼睛观察有一个1，1+0等于01，表示1的个数有一个即01。

上面是对三十二位二进制进行两两分组，可以分为16组，然后分别统计每一组中的1的个数。

接下来就是上一步结果再四四分组，分为8组，然后分别统计每一组中的1的个数。

  • 例如，二进制0010中高2位00，低2位10，二者相加00+10等于10表示有2个1（这两个1是第一步统计出来的结果，继续往下计算）
  • 例如，二进制0101中高2位01，低2位01，二者相加01+01等于10表示有2个1。

再接下来就是八八分组、十六十六分组、三十二三十二分组。

例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
两两分组，计算每组高1位和低1位中的1的个数，相加来计算
0011 1010 1101 1110 0110 1000 1011 0001
    ——   00  11  10  10 11   01 11  10   01 10  10   00  10  11 00   01
    ——  0+0 1+1 1+0 1+0 1+1 0+1 1+1 1+0 0+1 1+0 1+0 0+0 1+0 1+1 0+0 0+1
    ——   00  10  01 01 10    01 10  01   01 01  01  00   01  10  00 01
四四分组，计算每组高2位和低2位中的1的个数，相加来计算
0010 0101 1001 1001 0101 0100 0110 0001
    ——  0010    0101 1001 1001   0101 0100  0110   0001
    ——  00+10 01+01 10+01 10+01 01+01 01+00 01+10 00+01
    ——  0010  0010  0011  0011  0010  0001  0011  0001
八八分组，计算每组高4位和低4位中的1的个数，相加来计算
0010  0010  0011  0011  0010  0001  0011  0001
    ——  00100010  00110011  00100001  00110001
    ——  0010+0010 0011+0011 0010+0001 0011+0001
    ——  00000100  00000110  00000011  00000100
十六十六分组，计算每组高8位和低8位中的1的个数，相加来计算
00000100  00000110  00000011  00000100
    ——  0000010000000110   0000001100000100
    ——  00000100+00000110   00000011+00000100
    ——  0000000000001010  0000000000000111
三十二三十二分组，计算每组高16位和低16位中的1的个数，相加最后得到的二进制结果转换成十进制数就是该数中1的个数
0000000000001010  0000000000000111
    ——  0000000000001010  0000000000000111
    ——  0000000000001010+0000000000000111
    ——  0000000000000000 0000000000010001
    ——  17

上面只是实现的思路而已，下面用代码的方式来一步一步地模拟这个过程：

public static int bitCount(int i) {
    i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
    i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
    i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
    i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
    return i;
}
0x55555555     0101 0101 0101 0101 0101 0101 0101 0101
0x33333333     0011 0011 0011 0011 0011 0011 0011 0011
0x0f0f0f0f     0000 1111 0000 1111 0000 1111 0000 1111
0x00ff00ff     0000 0000 1111 1111 0000 0000 1111 1111
0x0000ffff     0000 0000 0000 0000 1111 1111 1111 1111
例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
①i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
    (i & 0x55555555)        0011 1010 1101 1110 0110 1000 1011 0001
                           &
                            0101 0101 0101 0101 0101 0101 0101 0101
                           =0001 0000 0101 0100 0100 0000 0001 0001   保留每两位中的低1位
    (i >>> 1)               0001 1101 0110 1111 0011 0100 0101 1000   将每二位原来的高1位1移动到低1位中
    ((i >>> 1) & 0x55555555)0001 1101 0110 1111 0011 0100 0101 1000
                           &
                            0101 0101 0101 0101 0101 0101 0101 0101
                           =0001 0101 0100 0101 0001 0100 0101 0000   保留每两位中的低1位（实际上是移动前中的每二位中的高1位）
    (i & 0x55555555) + ((i >>> 1) & 0x55555555)
                           0001 0000 0101 0100 0100 0000 0001 0001
                          +
                           0001 0101 0100 0101 0001 0100 0101 0000
                          =0010 0101 1001 1001 0101 0100 0110 0001
②i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
    (i & 0x33333333)       0010 0101 1001 1001 0101 0100 0110 0001
                          &
                           0011 0011 0011 0011 0011 0011 0011 0011
                          =0010 0001 0001 0001 0001 0000 0010 0001  保留每四位中的低2位
    (i >>> 2)              0000 1001 0110 0110 0101 0101 0001 1000  将每四位原来的高2位移动到低2位中
  ((i >>> 2) & 0x33333333) 0000 1001 0110 0110 0101 0101 0001 1000
                          &
                           0011 0011 0011 0011 0011 0011 0011 0011
                          =0000 0001 0010 0010 0001 0001 0001 0000  保留每四位中的低2位（实际上是移动前中的每四位中的高2位）
   (i & 0x33333333) + ((i >>> 2) & 0x33333333)
                           0010 0001 0001 0001 0001 0000 0010 0001
                          +
                           0000 0001 0010 0010 0001 0001 0001 0000
                          =0010 0010 0011 0011 0010 0001 0011 0001
③i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
    (i & 0x0f0f0f0f)       00100010 00110011 00100001 00110001
                          &
                           00001111 00001111 00001111 00001111
                          =00000010 00000011 00000001 00000001     保留每八位中的低4位
    (i >>> 4)              00000010 00100011 00110010 00010011     将每八位原来的高4位移动到低4位中
  ((i >>> 4) & 0x0f0f0f0f) 00000010 00100011 00110010 00010011
                          &
                           00001111 00001111 00001111 00001111
                          =00000010 00000011 00000010 00000011     保留每八位中的低4位（实际上是移动前中的每八位中的高4位）
  (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f)
                           00000010 00000011 00000001 00000001
                          +
                           00000010 00000011 00000010 00000011
                          =00000100 00000110 00000011 00000100
④i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
    (i & 0x00ff00ff)       0000010000000110 0000001100000100
                          &
                           0000000011111111 0000000011111111
                          =0000000000000110 0000000000000100        保留每十六位位中的低8位
    (i >>> 8)              0000000000000100 0000011000000011        将每八位原来的高8位移动到低8位中
  ((i >>> 8) & 0x00ff00ff) 0000000000000100 0000011000000011
                          &
                           0000000011111111 0000000011111111
                          =0000000000000100 0000000000000011        保留每十六位的低8位（实际上是移动前中的每十六位的高8位）
  (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff)
                           0000000000000110 0000000000000100
                          +
                           0000000000000100 0000000000000011
                          =0000000000001010 0000000000000111
⑤i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
    (i & 0x0000ffff)       00000000000010100000000000000111
                          &
                           00000000000000001111111111111111
                          =00000000000000000000000000000111         保留每三十二位的低16位
    (i >>> 16)             00000000000000000000000000001010         将每八位原来的高16位移动到低16位中
 ((i >>> 16) & 0x0000ffff) 00000000000000000000000000001010
                          &
                           00000000000000001111111111111111
                          =00000000000000000000000000001010         保留每三十二位的低16位（实际上是移动前中的每三十二位的高16位）
    (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff)
                           00000000000000000000000000000111
                          +
                           00000000000000000000000000001010
                          =00000000000000000000000000010001
                          =17（这就是最终的结果）

如图：

 比如四位二进制"0101"，我们要计算其中1的个数是要01+01=10，但是我们如何获得高2位"01"和低2位"01"，通过&0x33333333就可以获取每组中低2位的二进制了，那么要如何获取每组中高2位的二进制呢，就是将四位二进制无符号右移2位，即将"0101"无符号右移2位后的结果是"0001"这就获得了高2位的二进制了，再通过&0x33333333就可以真的可以获取每组中高2位的二进制了，之所以要&0x33333333是因为后面的加法运算排除其他数据。

 如上，i&0x0f0f0f0f也是为了获取每组的低4位

 如上，i&0x00ff00ff也是为了获取每组的低8位

如上，i&0x0000ffff也是为了获取每组中的低16位

而JDK中该方法的代码是优化过后效率更高的代码，但理解难度也大大提升：

    public static int bitCount(int i) {
        i = i - ((i >>> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        return i & 0x3f;
    }

第一行的优化是这样子的，我们知道01+01=10，这是通过加法计算得到的，但也可以通过减法得到，11-01=10，这就是通过减法计算得到的。（注：下面的代码没有用"0x55555555"而是用的是"0x5"，因为只有四位二进制参与模拟运算，所以只需要"0x5"转换成四位二进制参与运算即可，可以看到它们最终会得到相同的结果。但这个式子如何推导出来的仍不得而知。）

i=(i&0x5)+((i>>>1)&0x5)
 =0011&0101+((i>>>1)&0x5)
 =0001+((i>>>1)&0x5)
 =0001+0001
 =0010

i=i-((i>>>1)&0x5)
 =0011-((i>>>1)&0x5)
 =0011-0001
 =0010

第二行没有变化。

第三行，因为四位二进制可以表示最大15的数值（如二进制"1111"转换成十进制是15，所以可以表示15位的"1"），计算后用后四位表示一个八位的“1”数量足够，这样又可以少一次按位与运算，在上一步的时候两位二进制不足以表示四位二进制数的“1”的数量，为了效率，采用(i & 0x33333333) + ((i >>> 2) & 0x33333333)这种方式。计算后i的值所表示的二进制数表达的是每八位一个八位二进制数，每个八位二进制数的值表示这八位中“1”的数量，并且每个八位二进制数的前四位必然是0。

第四行、第五行只需要关注二进制的后六位就可以了，因为一个int类型的数是32位二进制，如果32位的二进制都是1，那么bitCount()方法得到的结果就是32，而2的6次方为64，我们的结果如"00000000000000000000000000010001"表示有17个1，这个17=1*2^0+0*2^1+0^2^2+0*2^3+1*2^4，而0x3f的二进制是"0000 0000 0000 0000 0000 0000 0011 1111"，转换成十进制数是1*2^0+1*2^1+1^2^2+1*2^3+1*2^4+1*2^5=63，所以一个int类型的数中的"1"的个数必然小于等于32位，即一定在"0000 0000 0000 0000 0000 0000 0011 1111"中的后6位中，而前面26位就不需要关心了，过滤掉即可，为了效率。

参考链接：

 

 

 

二木成林
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于jdk1.8的Java源码详解 Integer
08-25
基于jdk1.8的Java源码详解Integer Java中的Integer类是int类型的Warpper类，是面向对象的即OOP的对象类型。它继承了Number类，可以将Integer转换成int、double、float、long、byte和short类型的数据。同时，Integer...
bitCount-计算数字二进制中1的个数
dopamine_joker的博客
10-29 4904
这里写自定义目录标题1. 题目描述2. 解决方法3. bitcount解法分析4. 参考 主要介绍bitcount位运算实现，思路和java中bitcount的实现一样。 1. 题目描述 编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为 汉明重量).）。 LeetCode 2. 解决方法 解法1 第一反应就是直接暴力，代码如下: int hammingWeight(uint32_t n) { int ret = 0; for
bitcount函数c语言,Bit命令
weixin_39935903的博客
05-21 983
Bit命令命令简介：1)setbit：设置字符串指定偏移量bit2)getbit：获取字符串指定偏移量bit3)bitcount：获取字符串位中为1的数量4)bitpos：获取指定范围的位图中第一个值为bit的二进制位的位置5)bitop：对一个或者多个保存二进制位的字符串key进行位元操作，并且将结果保存到destkey上6)bitfield命令详解：1.setbit可用版本：>=2.2....
bitCount函数详解
XMJYever的博客
11-10 5293
最近刷题的时候看到了这样一个奇怪的函数，一开始非常不理解，后来查阅了资料，现将它记录下来。 int bitCount(int i) { // HD, Figure 5-2 i = i - ((i >>> 1) & 0x55555555); i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); i = (i + (i >>> 4)) &
redis (bitcount) 的汉明算法逻辑
gold615的博客
12-17 434
redis 中实现 bitcount 的汉明算法逻辑
比特位计数[动态规划 || bitCount计数]
最新发布
qq_43164662的博客
01-13 617
二进制计数可以直接基于分治去快速统计，如果是连续数的二进制计数，可以利用前面已经计算出的状态进行递推求解，即动态规划。
通过JDK源码角度分析Long类详解
08-28
通过JDK源码角度分析Long类的实现机制，可以发现Long类的实现主要依赖于native方法和Java层面的实现。例如，Long类的toString方法实际上是通过native方法getName0从JVM层获取名称的。 6. Long类的应用场景 Long类...
jdk1.6 源码jdk1.6 源码
06-07
4. **多线程**：JDK 1.6支持多线程编程，源码中包括了`Thread`类和`synchronized`关键字的实现，以及线程同步机制如`wait()`, `notify()`, `notifyAll()`。 5. **I/O流**：在`java.io`包中，你可以看到文件读写、...
关于equals()方法，jdk源码给出如下五点建议
12-21
在Java中，`equals()`方法的默认行为与`==`相似，但在许多内置类中，如`String`，`Integer`等，`equals()`已经被重写以比较对象的内容。 首先，让我们深入理解`equals()`方法在JDK源码中的应用。在`Object`类中，`...
jdk源码 jdk源码
02-01
Java Development Kit (JDK) 源码是学习和理解Java平台核心机制的关键资源。它包含了许多关键组件的源代码，使开发者能够深入探索Java语言的底层实现，从而提升编程技巧，优化性能，并理解标准库的工作原理。在这个...
Java之bitCount()方法
m0_61466268的博客
06-24 603
Integer.bitCount()方法
Integer.bitCount()理解
热门推荐
老齐
09-12 2万+
本文讨论内容基于Jdk1.7 bitCount实现的功能是计算一个（byte,short,char,int统一按照int方法计算）int,long类型的数值在二进制下“1”的数量。 网上关于此方法的解释已经不少，但大多晦涩难懂，我试图将这个问题描述的易于理解。
【Redis学习笔记】bitcount分析
weixin_34396902的博客
07-04 1494
顺风车运营研发团队 熊浩含一、命令简介BITCOUNT key [start] [end] redis计算给定字符串中，被设置为 1 的比特位的数量。 redis> BITCOUNT bits (integer) 0 redis> SETBIT bits 0 1 # 0001 (integer) 0 redi...
bitcount方法详解_Java Long类的bitCount（）方法和示例
cumt951045的博客
07-14 3155
bitcount方法详解 长类bitCount()方法 (Long class bitCount() method) bitCount() method is available in java.lang package. bitCount()方法在java.lang包中可用。 bitCount() method is used to find the number of 1's bits i...
java中Integer.bitCount()方法的实现(个人理解)
qq_33977728的博客
05-09 1万+
Integer.bitCount()方法用于统计二进制中1的个数。方法体如下： public static int bitCount(int i) { // HD, Figure 5-2 i = i - ((i >>> 1) & 0x55555555); ...
bitcount函数c语言,同事有话说：如何高效的统计出Bitmap中1的个数
weixin_33735281的博客
05-21 762
今天，我活泼可爱的同事们在群里欢快地讨论着一个问题：如何高效的统计出Bitmap中1的个数？那么问题来了，Bitmap是什么？BitmapA Bitmap or bitset is an array of zeros and ones. A bit in a bitset can be set to either 0 or 1, and each position in the array is ...
统计二进制中1的个数的两种方法：布赖恩·克尼根算法笔记附加Integer.bitCount()
weixin_45552562的博客
09-08 513
今天在刷leetcode的时候，忘记了布赖恩·克尼根算法，所以回过头来复习一遍，顺手写下来。 问题是：如何得到一个二进制数中1的数量？ 本质上的位运算要对原数进行移位运算，然后每次对其进行”取模运算（i % 2）“或者” AND 操作（i & 1）“来判断每次移位运算移过来的东西是1还是0(逐位比较边缘位置是否为 1)； 而布赖恩·克尼根位计数算法的基本思想是：使用特定比特位和算术运算移除等于 1 的最右比特位。 比如x：10001000 10001000 而x-1： 10001000 100001
bitcount方法详解_Java Integer类bitCount（）方法的示例
cumtv80668的专栏
07-10 861
bitcount方法详解 整数类bitCount()方法 (Integer class bitCount() method) bitCount() method is available in java.lang package. bitCount()方法在java.lang包中可用。 bitCount() method is used to find the number of 1's bits...
Java bitCount()方法
allway2的博客
03-02 2068
java.lang.Integer.bitCount()和java.lang.Long.bitCount()方法返回二进制表示的1的位数。有时将此功能称为人口计数。 public class BitCountDemo { public static void main(String[] args) { int i = 219; System.out.println("Number = " + i); /* * returns the string representation
深入解析Java源码：学习JDK源码的重要性与学习方法
Java源码解析是深入了解JDK源码的最佳途径之一。通过分析优秀的Java源码，我们能够提高自己的编程水平和代码质量。本文将以《Java源码解析》为主题，总结并分析其中包含的内容。 首先，在序章中，我们会明确讨论为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值