计算机在处置惩罚数据时，一次能直接处置惩罚的二进制数据的位数称为：字长。字长是指计算机一次能直接处置惩罚的二进制数据的位数，字长越长，计算机的团体机能越强。
 

 
计算机采纳二进制编码体式格局示意数、字符、指令和别的掌握信息。 计算机在存储、传送或操纵时，作为一个单元的一组二进制码称为字，一个字中的二进制位的位数称为字长。
 
平常称处置惩罚字长为8位数据的CPU叫8位CPU，32位CPU就是在同一时间内处置惩罚字长为32位的二进制数据。二进制的每个0或1是构成二进制的最小单元，称为位(bit)。经常使用的字长为8位、16位、32位和64位。字长为8位的编码称为字节，是计算机中的基础编码单元。
 
字长与计算机的功用和用处有很大的关联，是计算机的一个主要技术目标。字长直接反应了一台计算机的计算精度，为顺应差别的请求及谐和运算精度和硬件造价间的关联，大多数计算机均支撑变字长运算，即机内可完成半字长、全字长(或单字长)和双倍字长运算。在其他目标相同时，字长越大计算机的处置惩罚数据的速率就越快。初期的微机字长平常是8位和16位，386以及更高的处置惩罚器大多是32位。市面上的计算机的处置惩罚器大部分已达到64位。字长由微处置惩罚器对外数据通路的数据总线条数决议。
 
更多相干学问，请接见：Ki4网！
 
以上就是计算机一次能直接处置惩罚的二进制数据的位数称为什么？的细致内容，更多请关注ki4网别的相干文章！
 
收藏 | 0

概述
 
二进制位运算符用于直接对二进制位进行计算，一共有7个。
 
二进制或运算符（or）：符号为|，表示若两个二进制位都为0，则结果为0，否则为1。
二进制与运算符（and）：符号为&，表示若两个二进制位都为1，则结果为1，否则为0。
二进制否运算符（not）：符号为~，表示对一个二进制位取反。
异或运算符（xor）：符号为^，表示若两个二进制位不相同，则结果为1，否则为0。
左移运算符（left shift）：符号为<<，详见下文解释。
右移运算符（right shift）：符号为>>，详见下文解释。
头部补零的右移运算符（zero filled right shift）：符号为>>>，详见下文解释。
这些位运算符直接处理每一个比特位（bit），所以是非常底层的运算，好处是速度极快，缺点是很不直观，许多场合不能使用它们，否则会使代码难以理解和查错。
 
有一点需要特别注意，位运算符只对整数起作用，如果一个运算子不是整数，会自动转为整数后再执行。另外，虽然在 JavaScript 内部，数值都是以64位浮点数的形式储存，但是做位运算的时候，是以32位带符号的整数进行运算的，并且返回值也是一个32位带符号的整数。
 
i = i | 0;
 
上面这行代码的意思，就是将i（不管是整数或小数）转为32位整数。
 
利用这个特性，可以写出一个函数，将任意数值转为32位整数。
 
function toInt32(x) { return x | 0;
}
 
上面这个函数将任意值与0进行一次或运算，这个位运算会自动将一个值转为32位整数。下面是这个函数的用法。
 
toInt32(1.001) // 1 toInt32(1.999) // 1 toInt32(1) // 1 toInt32(-1) // -1 toInt32(Math.pow(2, 32) + 1) // 1 toInt32(Math.pow(2, 32) - 1) // -1 
 
上面代码中，toInt32可以将小数转为整数。对于一般的整数，返回值不会有任何变化。对于大于或等于2的32次方的整数，大于32位的数位都会被舍去。
 
二进制或运算符
 
二进制或运算符（|）逐位比较两个运算子，两个二进制位之中只要有一个为1，就返回1，否则返回0。
 
0 | 3 // 3 
 
上面代码中，0和3的二进制形式分别是00和11，所以进行二进制或运算会得到11（即3）。
 
位运算只对整数有效，遇到小数时，会将小数部分舍去，只保留整数部分。所以，将一个小数与0进行二进制或运算，等同于对该数去除小数部分，即取整数位。
 
2.9 | 0 // 2 -2.9 | 0 // -2 
 
需要注意的是，这种取整方法不适用超过32位整数最大值2147483647的数。
 
2147483649.4 | 0; // -2147483647 
 
二进制与运算符
 
二进制与运算符（&）的规则是逐位比较两个运算子，两个二进制位之中只要有一个位为0，就返回0，否则返回1。
 
0 & 3 // 0 
 
上面代码中，0（二进制00）和3（二进制11）进行二进制与运算会得到00（即0）。
 
二进制否运算符
 
二进制否运算符（~）将每个二进制位都变为相反值（0变为1，1变为0）。它的返回结果有时比较难理解，因为涉及到计算机内部的数值表示机制。
 
~ 3 // -4 
 
上面表达式对3进行二进制否运算，得到-4。之所以会有这样的结果，是因为位运算时，JavaScript 内部将所有的运算子都转为32位的二进制整数再进行运算。
 
3的32位整数形式是00000000000000000000000000000011，二进制否运算以后得到11111111111111111111111111111100。由于第一位（符号位）是1，所以这个数是一个负数。JavaScript 内部采用补码形式表示负数，即需要将这个数减去1，再取一次反，然后加上负号，才能得到这个负数对应的10进制值。这个数减去1等于11111111111111111111111111111011，再取一次反得到00000000000000000000000000000100，再加上负号就是-4。考虑到这样的过程比较麻烦，可以简单记忆成，一个数与自身的取反值相加，等于-1。
 
~ -3 // 2 
 
上面表达式可以这样算，-3的取反值等于-1减去-3，结果为2。
 
对一个整数连续两次二进制否运算，得到它自身。
 
~~3 // 3 
 
所有的位运算都只对整数有效。二进制否运算遇到小数时，也会将小数部分舍去，只保留整数部分。所以，对一个小数连续进行两次二进制否运算，能达到取整效果。
 
~~2.9 // 2 ~~47.11 // 47 ~~1.9999 // 1 ~~3 // 3 
 
使用二进制否运算取整，是所有取整方法中最快的一种。
 
对字符串进行二进制否运算，JavaScript 引擎会先调用Number函数，将字符串转为数值。
 
// 相当于~Number('011') ~'011' // -12 // 相当于~Number('42 cats') ~'42 cats' // -1 // 相当于~Number('0xcafebabe') ~'0xcafebabe' // 889275713 // 相当于~Number('deadbeef') ~'deadbeef' // -1 
 
Number函数将字符串转为数值的规则，参见《数据的类型转换》一章。
 
对于其他类型的值，二进制否运算也是先用Number转为数值，然后再进行处理。
 
// 相当于 ~Number([]) ~[] // -1 // 相当于 ~Number(NaN) ~NaN // -1 // 相当于 ~Number(null) ~null // -1 
 
异或运算符
 
异或运算（^）在两个二进制位不同时返回1，相同时返回0。
 
0 ^ 3 // 3 
 
上面表达式中，0（二进制00）与3（二进制11）进行异或运算，它们每一个二进制位都不同，所以得到11（即3）。
 
“异或运算”有一个特殊运用，连续对两个数a和b进行三次异或运算，a^=b; b^=a; a^=b;，可以互换它们的值。这意味着，使用“异或运算”可以在不引入临时变量的前提下，互换两个变量的值。
 
var a = 10; var b = 99;

a ^= b, b ^= a, a ^= b;

a // 99 b // 10 
 
这是互换两个变量的值的最快方法。
 
异或运算也可以用来取整。
 
12.9 ^ 0 // 12 
 
左移运算符
 
左移运算符（<<）表示将一个数的二进制值向左移动指定的位数，尾部补0，即乘以2的指定次方。向左移动的时候，最高位的符号位是一起移动的。
 
// 4 的二进制形式为100， // 左移一位为1000（即十进制的8） // 相当于乘以2的1次方 4 << 1 // 8 -4 << 1 // -8 
 
上面代码中，-4左移一位得到-8，是因为-4的二进制形式是11111111111111111111111111111100，左移一位后得到11111111111111111111111111111000，该数转为十进制（减去1后取反，再加上负号）即为-8。
 
如果左移0位，就相当于将该数值转为32位整数，等同于取整，对于正数和负数都有效。
 
13.5 << 0 // 13 -13.5 << 0 // -13 
 
左移运算符用于二进制数值非常方便。
 
var color = {r: 186, g: 218, b: 85}; // RGB to HEX // (1 << 24)的作用为保证结果是6位数 var rgb2hex = function(r, g, b) { return '#' + ((1 << 24) + (r << 16) + (g << 8) + b)
    .toString(16) // 先转成十六进制，然后返回字符串 .substr(1); // 去除字符串的最高位，返回后面六个字符串 }

rgb2hex(color.r, color.g, color.b) // "#bada55" 
 
上面代码使用左移运算符，将颜色的 RGB 值转为 HEX 值。
 
右移运算符
 
右移运算符（>>）表示将一个数的二进制值向右移动指定的位数。如果是正数，头部全部补0；如果是负数，头部全部补1。右移运算符基本上相当于除以2的指定次方（最高位即符号位参与移动）。
 
4 >> 1 // 2 /*
// 因为4的二进制形式为 00000000000000000000000000000100，
// 右移一位得到 00000000000000000000000000000010，
// 即为十进制的2
*/ -4 >> 1 // -2 /*
// 因为-4的二进制形式为 11111111111111111111111111111100，
// 右移一位，头部补1，得到 11111111111111111111111111111110,
// 即为十进制的-2
*/ 
 
右移运算可以模拟 2 的整除运算。
 
5 >> 1 // 2 // 相当于 5 / 2 = 2 21 >> 2 // 5 // 相当于 21 / 4 = 5 21 >> 3 // 2 // 相当于 21 / 8 = 2 21 >> 4 // 1 // 相当于 21 / 16 = 1 
 
头部补零的右移运算符
 
头部补零的右移运算符（>>>）与右移运算符（>>）只有一个差别，就是一个数的二进制形式向右移动时，头部一律补零，而不考虑符号位。所以，该运算总是得到正值。对于正数，该运算的结果与右移运算符（>>）完全一致，区别主要在于负数。
 
4 >>> 1 // 2 -4 >>> 1 // 2147483646 /*
// 因为-4的二进制形式为11111111111111111111111111111100，
// 带符号位的右移一位，得到01111111111111111111111111111110，
// 即为十进制的2147483646。
*/ 
 
这个运算实际上将一个值转为32位无符号整数。
 
查看一个负整数在计算机内部的储存形式，最快的方法就是使用这个运算符。
 
-1 >>> 0 // 4294967295 
 
上面代码表示，-1作为32位整数时，内部的储存形式使用无符号整数格式解读，值为 4294967295（即(2^32)-1，等于11111111111111111111111111111111）。
 
开关作用
 
位运算符可以用作设置对象属性的开关。
 
假定某个对象有四个开关，每个开关都是一个变量。那么，可以设置一个四位的二进制数，它的每个位对应一个开关。
 
var FLAG_A = 1; // 0001 var FLAG_B = 2; // 0010 var FLAG_C = 4; // 0100 var FLAG_D = 8; // 1000 
 
上面代码设置 A、B、C、D 四个开关，每个开关分别占有一个二进制位。
 
然后，就可以用二进制与运算，检查当前设置是否打开了指定开关。
 
var flags = 5; // 二进制的0101 if (flags & FLAG_C) { // ... } // 0101 & 0100 => 0100 => true 
 
上面代码检验是否打开了开关C。如果打开，会返回true，否则返回false。
 
现在假设需要打开A、B、D三个开关，我们可以构造一个掩码变量。
 
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 
 
上面代码对A、B、D三个变量进行二进制或运算，得到掩码值为二进制的1011。
 
有了掩码，二进制或运算可以确保打开指定的开关。
 
flags = flags | mask;
 
上面代码中，计算后得到的flags变量，代表三个开关的二进制位都打开了。
 
二进制与运算可以将当前设置中凡是与开关设置不一样的项，全部关闭。
 
flags = flags & mask;
 
异或运算可以切换（toggle）当前设置，即第一次执行可以得到当前设置的相反值，再执行一次又得到原来的值。
 
flags = flags ^ mask;
 
二进制否运算可以翻转当前设置，即原设置为0，运算后变为1；原设置为1，运算后变为0。
 
flags = ~flags;

按位逻辑运算，属性设置
 
按位逻辑运算在高效率的数据操作中应用很多，平时用的高级语言里面，多数时候不需要我们去手动设置这些，因为已经被封装在各种模块/类里面了。
 
在需要手动定义一些功能的时候，这些运算方法很值得使用。 
 有一点要注意就是，所有按位运算都是二进制位的按位运算，如果数据采用十进制或者十六进制表示，实际上也是采用二进制的按位运算。
 
按位与： &
 
 0&0=0； 1&0=0； 0&1=0； 1&1=1；
 
（1不变，0变为0） 
 例如 ： 1001&0011 = 0001 
 负数在计算机中是按照补码的形式存储的，所以要按照补码来按位运算 
 应用： 
 1，把指定位清零 。只需要和指定位为0，其他位为1的数进行&运算，这些位就为被置0 
 2，获取指定位。构造一个二进制数，需要获取的位为1，其他位为0，按位&运算，其结果就是数据的指定位。
 
按位或： |
 
0|0=0；   0|1=1；   1|0=1；    1|1=1；
 
（0不变，1变为1） 
 应用： 
 1，把数据的指定位设置为1。例如，如果要把第四位设置为1，那么需要构造一个二进制数：1000，将其与数据进行|预算，那么数据的第四位就会设置为1（不论之前是否是1）
 
按位异或：^
 
0^0=0；   0^1=1；   1^0=1；   1^1=0；
 
（0不变，1反转） 
 应用： 
 1，与1异或，可以翻转 
 2，与0异或，可以保留原值。 
 这两点很明确。
 
按位取反：~
 
~1=0；   ~0=1；
 
一个按位逻辑运算的应用：属性设置（这个应该有一个学名，暂时还不知道怎么说）
 
要对一个项目设置一些属性。如果是唯一性的属性倒还好办，比如说，一个项目，可能的属性为a,b,c，只能是其中一种，那么只需要设置这些属性值为一个静态常量，然后去判断一下就好了。
 
但是很多时候需要设置的属性是多种叠加的。比如说，可能属性是，a，b，c，d，e，f，g。 
 可以是其中一种，或者几种，可以是ac,也可以是dfg，也可以是e。并且这些属性并没有明确的分类，大多数都是同一类属性的叠加，所以不能分到不同的属性值里面去。 
 具体来讲，一个窗口，可以是 前台/最大化/透明/窗口化/默认位置/保持最上层 等等这些属性的一个或者几个的叠加。一个文件可以是 文件/文件夹/系统文件/隐藏文件/用户文件 等等这些的一个或者几个的叠加。
 
这个时候，像唯一属性那样判断就不好用了。最好的办法就是用按位逻辑运算。
 
假设一个项目的属性有8种。那么就构造一个8位二进制数（也就是2位十六进制数）。每一位对应一个属性，设置成静态常量。 
 a: 0000 0001 
 b: 0000 0010 
 c: 0000 0100 
 d: 0000 1000 
 ………… 
 如此一来，就可以用按位逻辑运算来构造属性值了。 
 比如说，我的属性值是abc，那么构造出的值就是：a|b|c. 
 根据之前的描述，| 运算将会使得对应1的位置是1，也就是说，a|b|c = 0000 0111，这也是一个唯一值，跟所有8种可能属性都不重复。类似的，我们也可以构造出其他的叠加属性，0100 1101，1001 0000 等等
 
判断属性的时候，需要用到 & 运算。 
 例如，判断一个项目是否有 a属性，可以：if((attr&a)==a) 
 根据上面的描述，& 的功能是 ：0变为0，1不变。也就是说, attr的值，对应a里面的为0的位，不管是否是0，都会编程0；对应a里面为1的位，则保持不变。 
 所以，如果attr有a这个属性，那么它的对应a属性的位就会是1，就保持为1；如果没有a这个属性，对应为就是0，运算后依然是0。 
 而其他位，不管是否是0，都会变成0.因此，可以用if((attr&a)==a)来判断属性。
 
同理，设置属性的时候用到 | 运算。 
 假设attr要设置成abcd，只需要简单的这样： attr = a|b|c|d；就可以了
 
大数（超过32位二进制数）
 
C语言早已支持64位，有单独的方法操作64位数（目前为止还没有试验过），但是多数时候我们还是在32位里面运算。
 
在没有支持64位数的时期，要存储一个大数据，比如文件大小，需要用到高低位的存储方法。就是说，在属性里面会对应两个值，一个是低32位，一个是高32位。
 
在数据量比较小的时候，高位始终为0。如果数据量在低位溢出，就会在高位中 +1。 
 需要注意一点就是，如果直接写出来的话，只有二进制/十六进制可以直接表示为 【高位-低位】，例如一个数是低位0x1820 ff11, 高位是0x1,那表示出来就是 0x1 1820 ff11 
 如果是十进制，就需要转换一下，因为高位的 0x1 表示成十进制的时候是 32位最大值+1
 
如果要做加法，需要高位/低位分开相加，如果低位产生了进位，那就在高位的结果里面加1. 
 怎么判断低位的进位呢？ 
 如果是无符号数，就简单了，因为进位以后的32位值对应的就只有这32位的值，第33位会被计算机直接忽略，所以，如果 结果小于任意一个相加值，就表示产生了进位。 
 numA + numB = result; 
 if(result<numA)………… 
 有符号数的情况还没有研究过。刚才这个方法也是在网上找到的，还没细看是否有bug。
 
高低位的表示方法转换成10进制
 
result = HIGH*(MAXDWORD + 1) + LOW 
 result – 真实结果 
 MAXDWORD – 32位数最大值 （0xFFFF FFFF）
 
那么，怎么表示在计算机里面呢？ 
 0xFFFF FFFF 十进制 就是 4 294 967 295，0x1 0000 0000 实际数值是 4 294 967 296，但是计算机里面直接把超过32位的数值舍去，所以计算机里面这个数就是0x0000 0000，也就是十进制数0
 
要在计算机上表示超过32位的数值，可以使用以下办法。(自己想的办法，不知道是不是实用)
 
保存一个指定位数（例如，20位十进制数）的字符数组char bit[20]; 
 将这个数组的每一个位上的字符，对应十进制数的每一个位的数字，然后按照普通的算法进行加减乘除操作。 
 加法就是 对位相加，如果进位，就在上一位加1。 
 乘法类似。 
 除法还没有仔细想过，以后再说吧。
 
所以，超过32位的数值可以用这种按位表示法来保存，输出的时候也不会存在溢出的问题。

 
二进制位运算笔记
 
基本数据类型所占字节和位数
十进制转r进制总结
十进制转换成二进制 采用短除2法:
二进制转换成十进制
  
二进制的位运算
基本概念
原码
反码
补码
  
二进制位运算
&运算
按位与运算的应用
可以判断一个数x的奇偶性
保留指定的位数
   
   
| 或运算
按位或运算的应用;
将一个数x指定位全部换成1
   
   
^ 异或运算
按位异或的应用：
定位反转
交换a和b的数值
   
   
~ 按位取反
<< 左移
>>右移
>>>无符号右移
  
Java中常见的进制转换
开发中位运算的小技巧
判断int型变量a是奇数还是偶数
求平均值
对于一个大于0的整数，判断它是不是2的几次方
比如有两个int类型变量x、y,要求两者数字交换
求绝对值
取模运算
乘法运算
除法运算转化成位运算
求相反数
a % 2 等价于 a & 1
 

 
基本数据类型所占字节和位数
 
Java的基本数据类型，以及在内存中所占的位数。（一个字节等于8位）
 
数据类型
所占字节
所占位数
byte
1
8
boolean
1
8
short
2
16
int
4
32
long
8
64
float
4
32
double
8
64
char
2
16
十进制转r进制总结
 
方法：除r取余，直至商0，余数倒叙排列！
 比如67这个数
 
十进制转换成二进制 采用短除2法:
 
除
商
余数
67 ÷ 2
33
1
33 ÷ 2
16
1
16 ÷ 2
8
0
8 ÷ 2
4
0
4 ÷ 2
2
0
2 ÷ 2
1
0
1 ÷ 2
0
1
商是0的时候结束，将余数从下往上数，即可得到二进制数结果 1000011
 
二进制转换成十进制
 
采用科学计数法，按位权展开;
 比如上面这个数1000011
 
 1*2^（1-1）+1*2^（2-1）+1*2^（7-1）=1+2+64=67；     
 
二进制的位运算
 
基本概念
 
1，先介绍二进制中几个基本的概念原码,反码,补码：
 补充一下所有计算机中这些码可以理解为一种规定标准，就是说计算机里以何种标准来存储二进制；
 
在计算机中，参与运算的是二进制数的补码形式
 
原码
 
就是一个数的二进制形式，比如
 
 00000000 00000000 00000000 00001000	//是8(int)的原码
 10000000 00000000 00000000 00001000	//是-8(int)的原码
 
其中，最高位为符号位：正数为0，负数为1。剩下的n-1位表示该数的绝对值，
 
PS：正数的原、反、补码都一样
 
0的原码跟反码都有两个，因为这里0被分为+0和-0。
 
 
反码
 
反码就是在原码的基础上，符号位不变其他位按位取反 (就是0变1，1变0)就可以了
 对于负数 它的原码各个位数取反 。比如 -8
 
10000000 00000000 00000000 00001000	//取反
11111111 11111111 11111111 11110111
 
 
补码
 
补码就是在反码的基础上+1.
 例如-8表示如下：
 -8的二进制代码
 
10000000 00000000 00000000 00001000
 
取反后的反码
 
11111111 11111111 11111111 11110111
 
末位加上1得补码
 
11111111  11111111 11111111 11111000
 
二进制逢2进1
 
总结：
 
正数：
 
原码=反码=补码
 
负数：
 
原码
反码 = 其原码除符号位之外的各位取反
补码=反码+1 （如果+1之后有进位的，要一直往前进位，包括符号位）
 
 
二进制位运算
 
在二进制里面
 
整型int使用32个字节，32位,其中最高位为0表示的是正数，最高位为1表示的是负数
其中0含义代表的是false,1含义表示true
在接触位运算符的时候，把1想成true,把0想成false,结果为true代表1，结果为false代表0，
 
这个感觉是不是和java逻辑运算符差不多！
 
&运算
 
按位与运算 两位都为1，结果才是1；0&0=0；0&1=0；1&0=0；1&1=1
是不是可以理解成两个都为true,结果才是true*
 
		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
		int c = a & b;// == 00000000 00000000 00000000 00001000(2)
		System.out.println(c);// c=8
 
按位与运算的应用
 
可以判断一个数x的奇偶性
 
x&1=0,说明x是偶数
x&1=1,说明x是奇数
 
		System.out.println(a & 1);// 结果0,说明a是偶数
		System.out.println(b & 1);// 结果1,说明b是奇数
 
保留指定的位数
 
比如想保留数a的后8位
 
0xff是16进制，转换二进制00000000 00000000 11111111 1111111
 
		System.out.println(a = a & 0xff);// ==00000000 00000000 00000000 00001000(2)
		System.out.println(Integer.toBinaryString(a & 0xff));
 
 
| 或运算
 
按位或 只要有一个为1，结果就为1；0|0=0；0|1=1；1|0=1；1|1=1
是不是可以理解成两个中有一个为true,结果就是true
 
		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
		int c = a | b;// == 00000000 00000000 00000000 00001001(2)
		System.out.println(c);// c=9
 
按位或运算的应用;
 
将一个数x指定位全部换成1
 
比如上面的a
 
	int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
 
		//数a的后8位全部变成1
		System.out.println(a = a | 0xff);//== 00000000 00000000 00000000 11111111(2)
		System.out.println(Integer.toBinaryString(a | 0xff));
 
 
^ 异或运算
 
按位异或运算 相应位值不同，则该位结果为1，否则为0；00=0；01=1；10=1；11=0**
是不是可以理解成两个都不为true或者false时,结果才是true
 
		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
		int c = a ^ b;// == 00000000 00000000 00000000 00000001(2)
		System.out.println(c);// c=1
 
按位异或的应用：
 
定位反转
 
将一个数x的0位变成1,1位变成0
 
		System.out.println(a ^ 0xff);// == 00000000 00000000 00000000 11110111(2)
		System.out.println(Integer.toBinaryString(a ^ 0xff));
 
交换a和b的数值
 
		a = a ^ b;
		b = b ^ a;
		a = a ^ b;
		System.out.println(a);// 9
		System.out.println(b);// 8
 
 
~ 按位取反
 
按位取反 将一个位上的数按位取反，即0变成1,1变成0；~1=0 ; ~0=1
是不是可以理解成！true,结果是false,！false,结果是true.
 
先了解一下下面负数二进制表示形式;上面说了，负数以其正值的补码形式表示
 比如 int a = 8的取反过程
 
	// 8原码             00000000 00000000 00000000 00001000(2)
 
	//  取反             11111111 11111111 11111111 11110111(2) 是个负数
 
	// 减1            	 11111111 11111111 11111111 11110110(2) 得到了负数绝对值的反码
 
	// 取反              00000000 00000000 00000000 00001001(2) 的到了负数的绝对值
 
	//转换十进制  等于   9，所以结果是 -9 ;
	System.out.println(a);// -9
 
负数以其正值的补码形式表示，补码等于负数绝对值的反码+1
 
 
<< 左移
 
将一个运算对象的各二进制位全部左移若干位
左边的二进制位丢弃，右边补0
 
		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
		int b = -8;// -8(10)=11111111 11111111 11111111 11111000(2)
		System.out.println(a << 1);// 00000000 00000000 00000000 00010000(2)==16(10)
		System.out.println(b << 1);// 11111111 11111111 11111111 11110000(2)==-16(10)
 
左移的规律：
 
一个数y左移n位(y<< n)，就相当于这个数乘以2^n；
 
 
>>右移
 
将一个运算对象的各个二进制位全部右移若干位
是正数，左边的二进制位补0
是负数，左边二进制位补1
右边统统舍弃
 
		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
		int b = -8;// -8(10)=11111111 11111111 11111111 11111000(2)
		System.out.println(a >> 1);// 00000000 00000000 00000000 00000100(2)==16(4)
		System.out.println(b >> 1);// 11111111 11111111 11111111 11111100(2)==-16(4)
 
右移的规律
 
一个数y右移n位(y>> n)，就相当于这个数除以2^n；
 
 
>>>无符号右移
 
各个位向右移指定的位数
右移后左边空出的位用零来填充
移除右边的位被舍弃
 
		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
		int b = -8;// -(10)=11111111 11111111 11111111 11111000(2)
		System.out.println(a >>> 1);// 00000000 00000000 00000000 00000100(2)==4(4)
		System.out.println(b >>> 1);// 01111111 11111111 11111111 11111100(2)==2147483644(4)
 
 
Java中常见的进制转换
 
		/**
		 二进制：数字前面加上“0b”例如0b10010
		 八进制：数字前面加上“0” 例如"0123"
		 十六进制：数字前面加上“0x" 例如”0x12" 
		 */
		int num = 0b10010;
		String str = "10010";
		System.out.println(Integer.toBinaryString(num));// 转化为2进制
		System.out.println(Integer.toString(num, 2));// 转化为2进制
		System.out.println(Integer.toOctalString(num));// 转化为8进制
		System.out.println(Integer.toString(num, 8));// 转化为8进制
		System.out.println(Integer.toHexString(num));// 转化为16进制
		System.out.println(Integer.toString(num, 16));// 转化为16进制
		System.out.println(Integer.toString(num));// 转化为10进制
		System.out.println(Integer.toString(num, 10));// 转化为10进制
		System.out.println("-------------------------------------");
		System.out.println(Integer.parseInt(str, 2));// 把2进制数解析成10进制
		System.out.println(Integer.parseInt(str, 8));// 把8进制数解析成10进制
		System.out.println(Integer.parseInt(str, 10));// 把10进制数解析成10进制
		System.out.println(Integer.parseInt(str));// 默认把数看成是10进制，转化为10进制
		System.out.println(Integer.parseInt(str, 16));// 把16进制数解析成10进制
 
开发中位运算的小技巧
 
判断int型变量a是奇数还是偶数
 
 
a&1 = 0 偶数
 
 
a&1 = 1 奇数
 
 
求平均值
 
比如有两个int类型变量x、y,首先要求x+y的和，再除以2，但是有可能x+y的结果会超过int的最大表示范围，所以位运算就派上用场啦
 
    (x&y)+((x^y)>>1); 
 
对于一个大于0的整数，判断它是不是2的几次方
 
    ((x&(x-1))==0)&&(x!=0)； 
 
比如有两个int类型变量x、y,要求两者数字交换
 
位运算的实现方法：性能绝对高效
 
	   	x ^= y; 
	
	    y ^= x; 
	
	    x ^= y; 
 
求绝对值
 
	   int abs( int x ) 
	  { 
	    int y ; 
	    y = x >> 31 ; 
	   return (x^y)-y ;  
	   //or: (x+y)^y 
	  }
 
取模运算
 
采用位运算实现：
 
     a % (2^n) 等价于 a & (2^n - 1) 
 
乘法运算
 
采用位运算实现
 
     a * (2^n) 等价于 a << n
 
除法运算转化成位运算
 
  	 a / (2^n) 等价于 a>> n 
 
求相反数
 
      (~x+1) 
 
a % 2 等价于 a & 1
 
 
 
若有问题欢迎指正，互相学习，共同进步！