「WTF系列」深入Java中的位操作

• 關(guān)于WTF系列

引

學(xué)完本章節(jié)你將學(xué)會位的基礎(chǔ)概念與語法，并且還會一些騷操作！！

• 與、或、非、位移
• 原碼、反碼、補(bǔ)碼
• 字節(jié)、位、超區(qū)間......

開始本章節(jié)之前，我們先思考一個問題：

byte a = 33;
byte b = -3;

若我們輸出a、b的二進(jìn)制字符串是多少？

答案是這樣的么？

a->// 00100001
b->// 10100001

當(dāng)然同學(xué)們可能會覺得我既然問了就肯定不是這樣；是吧～別著急你們試試就知道了。

在Java中輸出一個值對應(yīng)的二進(jìn)制方法有很多，這里提供一個簡單的方法：

int value = 33;
String bs = String.format("%32s", Integer.toBinaryString(value)).replace(" ", "0");

在方法中是int值，int占4字節(jié)32位，所以是：“%32s” 若是byte將32改成8即可；當(dāng)然對于byte你還需要加上“&0xFF”來做高位清零操作。

String bs = String.format("%8s", Integer.toBinaryString(value&0xFF)).replace(" ", "0");

基本原則

在Java中是采用的有符號的運(yùn)算方式，故：高位為符號位，其余位存儲數(shù)據(jù)信息。

簡單來說：

+1 ->// 00000001
-1 ->// 10000001

默認(rèn)例子中的值都按byte來算，占8位，減少大家的記憶負(fù)擔(dān)。

因為byte占8位，所以有效數(shù)據(jù)存儲7位，最高位為符號位。int值則是31位存儲數(shù)據(jù)。

• 0 代表正數(shù)
• 1 代表負(fù)數(shù)

上述的-1的表示方法其實并不是機(jī)器碼，而是人腦的理解方式。

我們認(rèn)為+1與-1的差異就是高位不同而已，這是我們基于自然規(guī)律來看的；而機(jī)器真正存儲的值其實是：11111111；這里其實就給大家提到了最初的問題。

二進(jìn)制的計算規(guī)則是：逢2進(jìn)1

這個很好理解，因為表示的數(shù)字就是：0、1兩個數(shù)字，想要表示更大的值就只能往前遞增進(jìn)步。

在平時生活中是逢10進(jìn)1；因為咱們有10個數(shù)字：9、8、7、6、5、4、3、2、1、0；所以11就是：當(dāng)為0|9增加為10的時候就進(jìn)一格所以變成：1|0，個位再把剩余的1補(bǔ)上就是：1|1；所以就是11。

那么：

1就是：0|0|0|0|0|0|0|1 
2就是：0|0|0|0|0|0|1|0 
3就是：0|0|0|0|0|0|1|1
4就是：0|0|0|0|0|1|0|0  

運(yùn)算法則

image-20181229100325309

設(shè)

byte a = (byte) 0b01011000;  // 88
byte b = (byte) 0b10101000;  // -88
int n = 1;

按位與 a & b

image-20181227113852053

輸入2個參數(shù)

a、b對應(yīng)位都為1時，c對應(yīng)位為1；反之為0。

**按位或 a | b****

image-20181227113946327

輸入2個參數(shù)

a、b對應(yīng)位只要有一個為1，c對應(yīng)位就為1；反之為0。

按位異或 a^b

image-20181227114005969

輸入2個參數(shù)

a、b對應(yīng)位只要不同，則c對應(yīng)位就為1；反之為0。

按位取反(非)

image-20181227115107965

輸入1個參數(shù)

c對應(yīng)位與輸入?yún)?shù)a完全相反；a對應(yīng)位為1，則c對應(yīng)位就為0；a對應(yīng)位為0，則c對應(yīng)位就為1。

左移

image-20181227115525706

輸入1個參數(shù)a；n = 1

a對應(yīng)位全部左移動n位得到c；a最左邊的n個位全部丟棄（紅色框），c最右邊n個位補(bǔ)充0（綠色框）。

右移（帶符號）

image-20181227150135326

輸入1個參數(shù)b；n = 1

這里將參數(shù)換為b是因為b為負(fù)數(shù)，第一個位為1

b對應(yīng)位全部右移動n位得到c；b最右邊n個位全部丟掉（紅色框），c最左邊n個位補(bǔ)充1（綠色框）。

這里需要注意的是其左邊補(bǔ)充的值取決于b的最高位也就是符號位：符號位是1則補(bǔ)充1，符號位是0則補(bǔ)充0。

右移（無符號）

image-20181227151319711

輸入1個參數(shù)b；n = 1

這里將參數(shù)換為b是因為b為負(fù)數(shù)，第一個位為1

b對應(yīng)位全部右移動n位得到c；b最右邊n個位全部丟掉（紅色框），c最左邊n個位補(bǔ)充0（綠色框）。

這里需要注意的是其左邊補(bǔ)充的值永遠(yuǎn)為0，不管其最高位（符號位）的值。

進(jìn)制表示規(guī)范

這個小節(jié)是插曲，部分同學(xué)可能注意到上面寫的進(jìn)制定義是：0b01011000，部分同學(xué) 可能疑惑為什么不是 0x 之類的。

前綴

• 十進(jìn)制：直接寫數(shù)字即可
• 二進(jìn)制：0b或0B開頭；如：0b01011000 代表十進(jìn)制 88
• 八進(jìn)制：0 開頭；如：0130 代表十進(jìn)制 88 （1x64+3x8）
• 十六進(jìn)制：0x或0X開頭；如：0x58 代表 88 (5x16+8)

后綴

• 0x?? 若小于127 則按byte算，大于則按int類型算
• 0xFF默認(rèn)為int類型
• 若聲明為long添加后綴：L或l：如：0xFFL 或 0xFFl
• 帶小數(shù)的值默認(rèn)為double類型；如：0.1
• 若聲明為float添加后綴：f 或 F：如：0.1F
• 若聲明為double添加后綴：d或D：如：1D

范圍

• 二進(jìn)制：1、0
• 八進(jìn)制：0～7
• 十進(jìn)制：0～9
• 十六進(jìn)制：0～9 + A～F

類型轉(zhuǎn)換

在上述運(yùn)算法則中：兩個不同長度的數(shù)據(jù)進(jìn)行位運(yùn)算時，系統(tǒng)會將二者按右端對齊左端補(bǔ)齊，然后進(jìn)行位運(yùn)算。

設(shè)

• a 為 int 占32位
• b 為 byte 占8位

執(zhí)行： a&b 、a|b 、a^b….等操作時：

1. 若b為正數(shù)，則左邊補(bǔ)齊24個0
2. 若b為負(fù)數(shù)，則左邊補(bǔ)齊24個1

若b = 0b01011000 補(bǔ)齊后：0b 00000000 00000000 00000000 01011000

若b = (byte) 0b10101000 補(bǔ)齊后：0b 11111111 11111111 11111111 10101000

為什么 b = 0b10101000 需要加上 (byte) 強(qiáng)轉(zhuǎn)？

因為默認(rèn)的0b10101000會被理解為：0b 00000000 00000000 00000000 10101000，這個值是一個超byte范圍的int值（正數(shù)）：168。

當(dāng)強(qiáng)轉(zhuǎn) byte 后高位丟棄，保留低8位，對于byte來說低8中的高位就是符號位；所以運(yùn)算后就是：-88（byte）。

原碼、反碼、補(bǔ)碼

相信看了上面那么多的各種規(guī)定后，大家有一定的疑問，為什么正數(shù)與負(fù)數(shù)與大家所想的不大一樣呢？

我相信大家覺得正數(shù)負(fù)數(shù)就是這樣的：

// 錯誤的理解
// 0b01011000 -> 88  ： (64+16+8)
// 0b11011000 -> -88 ： -(64+16+8)

大家可能會想，正數(shù)與負(fù)數(shù)不就應(yīng)該只是差符號位的變化么？

// 正確的理解
// 0b01011000 -> 88  ： (64+16+8)
// 0b10101000 -> -88 ： -(64+16+8)

0b10101000 ： -(64+16+8) ？？WTF？？ 除了符號位能懂以外請你告訴我是怎么得出 64、16、8的？

在這里我們先設(shè)兩個基本的概念：

• 原碼：人所能直接理解的編碼
• 機(jī)器碼：計算機(jī)能直接理解的編碼

允許我先說一個小故事：對于在坐的各位來說計算1-1是非常簡單的，但是對于計算機(jī)來說就是計算：00000001 與 10000001 （暫且按8位，原碼）。

image-20181227162239126

計算機(jī)需要識別出橙色部分的符號位，然后提取出粉色部分的數(shù)據(jù)進(jìn)行計算；這里有兩個問題：

1. 識別橙色符號位是困難的
2. 若橙色部分是負(fù)數(shù)則需要增加減法計算模塊

但對于計算機(jī)來說做加法就夠了，將1-1換算為：1+（-1）；OK這一步就是將所有的減法都換算為加法進(jìn)行計算，減少了減法硬件模塊的設(shè)計，提升了計算機(jī)的硬件利用率。

但是這里就有一個問題了，既然是將-1當(dāng)作了一個值來進(jìn)行運(yùn)算，那么必然這個值需要方便做加法才行；按上圖來說我們必不可免的需要去做一次符號位的判斷，然后再做數(shù)據(jù)位的減法操作，簡單來說還是在做減法。

所以若計算機(jī)的機(jī)器碼直接采用原碼則會導(dǎo)致硬件資源的設(shè)計問題。

有沒有一種辦法將符號位直接存儲到整個結(jié)構(gòu)中，讓計算機(jī)在計算過程中不去管所謂的符號位與數(shù)據(jù)位？有的！就是反碼。

反碼

• 正數(shù)的反碼是其本身
• 負(fù)數(shù)的反碼是在其原碼的基礎(chǔ)上, 符號位不變，其余各個位取反?？梢院唵卫斫鉃?"~a | 10000000"

[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反

image-20181227163556584

如上圖，咱們將 -1 的原碼轉(zhuǎn)化為了反碼；此時我們使用 反[+1] + 反[-1] 進(jìn)行一次運(yùn)算：

image-20181227164122945

此時咱們可以得到一個值x，這個值可以確定的是符號位為1，為負(fù)數(shù)，后面數(shù)據(jù)位全部為1；因為此時是反碼狀態(tài)，所以要想我們能直接讀取數(shù)據(jù)是不是應(yīng)該轉(zhuǎn)化為原碼狀態(tài)啊。

// 反碼轉(zhuǎn)原碼流程就是倒過來，符號位不變，其余位為取反即可。
1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原= [00000001]反 + [11111110]反 = [11111111]反 = [10000000]原 = -0

可以看出我們已經(jīng)解決好了運(yùn)算的問題了，計算機(jī)只需要按照反碼的方式去計算即可，只需要做加法，不需要做減法就可以運(yùn)算減法流程。計算完成后對于人腦來說需要將反碼轉(zhuǎn)化為原碼就是可讀的數(shù)據(jù)了。

但上述也暴露一個問題：-0 的問題；對于0的表示將會出現(xiàn)兩種情況：

• [11111111]反 = [10000000]原 = -0
• [01111111]反 = [00000000]原 = +0

也就是出現(xiàn)兩種為0的表示值，-0與+0；但對于我們來說0就是0，不需要做區(qū)分。所以又引入了補(bǔ)碼。

補(bǔ)碼

• 正數(shù)與反碼規(guī)則一樣無需變化：補(bǔ)碼=反碼=原碼
• 負(fù)數(shù)在反碼基礎(chǔ)上保證符號位不變，從右端+1

[+1] = [00000001]原 = [00000001]反 = [00000001]補(bǔ)
[-1] = [10000001]原 = [11111110]反 = [11111111]補(bǔ)

image-20181227170001363

此時若計算機(jī)使用補(bǔ)碼直接進(jìn)行計算會怎樣？

image-20181227170750910

當(dāng)我們使用補(bǔ)碼計算時，因為末尾的兩位均為1，1+1 = 2；對于二進(jìn)制來說滿2進(jìn)1，所以往前進(jìn)位1，進(jìn)位后又遇到 1+1 = 2的情形，所以依次進(jìn)位，當(dāng)前位置0。

最終計算后就是：1 00000000 ，一共9位，因為當(dāng)前只有8位，所以自然就只剩下：00000000 。

請注意：在當(dāng)前運(yùn)算過程中符號位并無差別也直接當(dāng)作普通值進(jìn)行步進(jìn)運(yùn)算！

如此我們就完成了整個流程的運(yùn)算，但你還需注意的是，當(dāng)前運(yùn)算后的值是補(bǔ)碼，也就是機(jī)器直接操作的編碼；如果要還原為我們可讀的值需要反向轉(zhuǎn)化為原碼。由最初定義可知，正數(shù)：原碼=補(bǔ)碼；上述補(bǔ)碼為正數(shù)，所以原碼也是：00000000。整個流程如下：

// 補(bǔ)碼計算流程
1 - 1 = 1 + (-1) 
= [00000001]原 + [10000001]原 
= [00000001]反 + [11111110]反 
= [00000001]補(bǔ) + [11111111]補(bǔ)
= [00000000]補(bǔ)
= [00000000]原
= 0

補(bǔ)碼->原碼

正數(shù)的補(bǔ)碼就是原碼

負(fù)數(shù)：

1. 直接倒敘流程，保證符號位不變右端減1，再保證符號位不變其余位取反即可
2. 再走一遍補(bǔ)碼流程；補(bǔ)碼的補(bǔ)碼就是原碼（先取反再+1即可）【敲黑板】

思考[10000000]代表什么？

若是某個計算完成后的補(bǔ)碼值為：10000000 那么他對應(yīng)的值是什么呢？

// 按方案1來看：
[10000000]補(bǔ) = [11111111]反 = [10000000]原
// 按方案2來看：
[10000000]補(bǔ) = [11111111]補(bǔ)反 = [10000000]補(bǔ)補(bǔ) = [10000000]原
可見方案1、方案2都是一樣的，補(bǔ)碼的補(bǔ)碼就是原碼。

[10000000]原 = 是等于0呢？還是-0呢？還是-128呢？

因為我們已經(jīng)規(guī)定了：[00000000]原 = 0；為了充分利用位的存儲區(qū)間，所以將：[10000000]原 = -128

一般情況下不會對[10000000]補(bǔ)碼求原碼，因為也沒啥意義～

思考(127、-127)原碼、反碼、補(bǔ)碼是多少？

對于正數(shù)：

127 = [01111111]原 = [01111111]反 = [01111111]補(bǔ)

對于負(fù)數(shù)：

-127 = [11111111]原 = [10000000]反 = [10000001]補(bǔ)

對于計算機(jī)來說，其存儲的值都是補(bǔ)碼，所以也就造成了一開始我們提到的問題：為什么88與-88的二進(jìn)制并不只是符號位不同？

再次強(qiáng)調(diào)：計算機(jī)存儲的是補(bǔ)碼，為了方便運(yùn)算；我們想要理解其表示的值需要轉(zhuǎn)化為原碼。

溢出問題

因為計算機(jī)計算過程中不再區(qū)別符號位，直接將符號位也納入運(yùn)算流程中；所以也就可以解釋2個基礎(chǔ)問題：（溢出）

1. 兩個正數(shù)相加為負(fù)數(shù)
2. 兩個負(fù)數(shù)相加為正數(shù)

大家可以分析一下：

1. 88+100
2. (-66) + (-88)

上述計算在byte變量范圍下進(jìn)行計算，嘗試分析一下補(bǔ)碼的計算流程。

存儲區(qū)間

默認(rèn)的對于采用補(bǔ)碼的計算機(jī)系統(tǒng)而言，其存儲值的有效范圍是：-2^(n-1) ~ 2^(n-1) -1 ；n代表當(dāng)前的位數(shù)。

• byte，1字節(jié)，8位：-2^7 ~ 2^7 -1 = -128~127
• short，2字節(jié)，16位：-2^15 ~ 2^15 -1 = -32768 ～ 32767
• int，4字節(jié)，32位：2^31 ~ 2^31 -1
• ......

若，我想在byte中存儲超過127的值會怎樣？

設(shè)：

• int i = 200
• 對應(yīng)補(bǔ)碼為： 0000 0000 0000 0000 0000 0000 1100 1000
• 因200未超256（2^8）所以依然只會使用到8個位

int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) 200; // 1100 1000

當(dāng)我們將200強(qiáng)轉(zhuǎn)為byte時高位丟棄僅剩下低8位：1100 1000

如果我們對byte進(jìn)行輸出會怎樣？

System.out.println(b); // "-56"

首先其直接調(diào)用的是：public void println(int x) 方法，OK，既然是int輸出為啥不是200？而是-56？

就算有這樣的方法：public void println(byte x) 方法，會輸出200么？也不會！！

首先對于byte b來說：1100 1000 這是一個負(fù)數(shù)的補(bǔ)碼，其原碼流程是：

[1100 1000]補(bǔ) = [1011 0111] = [1011 1000]原 = -(32+16+8) = -56

這里有一個有趣的事情，int轉(zhuǎn)byte時是直接丟掉高位的所有數(shù)據(jù)：24個0；但byte轉(zhuǎn)int時，補(bǔ)充高24位時是根據(jù)當(dāng)前的符號位來補(bǔ)充的，若當(dāng)前符號位是1則添1，若符號位是0則添0；對于byte來說第一位就是符號位，當(dāng)前的1100 1000符號位是“1”所以添加的就是24位1。

int c = b; // b -> 1100 1000
// c -> 1111 1111 1111 1111 1111 1111 1100 1000

若直接打印的是byte值，就是-56；上面我們分析1100 1000的原碼時就已經(jīng)證明了。那么打印c是不是呢？

對于范圍較少的類型轉(zhuǎn)換位大類型時不會丟失數(shù)據(jù)，原來是什么就是什么。

OK，就算不是上面那句話，我們來看看：

[1111 1111 1111 1111 1111 1111 1100 1000]補(bǔ)
= [1000 0000 0000 0000 0000 0000 0011 0111]
= [1000 0000 0000 0000 0000 0000 0011 1000]原
= -(32+16+8) = -56

若我們轉(zhuǎn)換為int時想要還原最初的200這個值該如何辦？

分析上面的補(bǔ)碼，可以看出其與最初的補(bǔ)碼差異僅僅在于左邊24位的不同：

[1111 1111 1111 1111 1111 1111 1100 1000]補(bǔ) = -56
[0000 0000 0000 0000 0000 0000 1100 1000]補(bǔ) = 200

那么我們只需要將前面的24位重置為0即可，這里就有一個與操作的簡單用法：

/**
 *
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &
 * 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b & 0xFF); // "200"

在這里我們做了一次特殊的：b & 0xFF 操作，b 轉(zhuǎn)換為int之后的值與 0xFF 進(jìn)行按位與操作。

0xFF = 255 其int原碼為：0000 0000 0000 0000 0000 0000 1111 1111，恰好最后8位為1，其余24位為0；所以可以用來做高位擦除操作。

這樣的用法可用以存儲超范圍的數(shù)據(jù)，比如對于文件的大小來說永遠(yuǎn)都是 >= 0，不可能會使用到 < 0 的值，所以對于原始的我們可以根據(jù)這個，使用較少的byte表示更多的區(qū)間，簡單來說就是無符號。將符號位也用以存儲數(shù)據(jù)。

int i = 0xFF60; // 65376
System.out.println(i);
// 00000000000000001111111101100000
System.out.println(String.format("%32s", Integer.toBinaryString(i)).replace(" ", "0"));

byte b1 = (byte) i; 
byte b2 = (byte) (i >> 8); 
// 01100000
System.out.println(String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(" ", "0"));
// 11111111
System.out.println(String.format("%8s", Integer.toBinaryString(b2 & 0xFF)).replace(" ", "0"));

int ret = (b1 & 0xFF) | (b2 & 0xFF) << 8;
System.out.println(String.format("%32s", Integer.toBinaryString(ret)).replace(" ", "0"));
// 65376
System.out.println(ret);

若沒有做 & 0xFF 操作，其值應(yīng)是：

/*
 * 0000 0000 0000 0000 0000 0000 0110 0000 (b1)
 * |
 * 1111 1111 1111 1111 1111 1111 0000 0000 (b2<<8)
 * =======================================
 * 1111 1111 1111 1111 1111 1111 0110 0000 (-160)
 */
System.out.println(b1 | b2 << 8); // "-160"

65376 本質(zhì)來說超過了short的存儲范圍：-32768~32767 ，但其在int中依然只需占2個字節(jié)16位：65376<65536。所以我們只需要使用2個byte即可存儲，而不需要int的4個byte來存儲。

在Socket傳輸中使用這樣的方式能有效降低傳輸?shù)淖止?jié)冗余。

案例-多Flag存儲在一個byte中

有這樣一個情形：一個四邊形，四條邊可以是虛線也可以是實線，四條邊相互獨(dú)立；定義為 a\b\c\d 四邊；此時我們需要在畫布上畫出這個四邊形；但是因為4邊相互獨(dú)立，所以我們常見的就是定義4個bool值：

boolean a = true;
boolean b = false;
boolean c = false;
boolean d = true;

void changeA(boolean fullLine) {
    a = fullLine;
}

簡單來說我們定義這樣的方式其一比較麻煩，其二總占用的內(nèi)存空間至少是4個byte，也有可能是16byte（按int存的情況）。

但是我們表示的內(nèi)容無非就是2種：實線、虛線

所以我們可以這樣做：

static byte a = 0b00000001;
static byte b = 0b00000010;
static byte c = 0b00000100;
static byte d = 0b00001000;

byte x = 0b00000000;

定義a、b、c、d為static，并且使用最后的4位即可。

若我們想要改變a邊的實虛：

void changeA(boolean fullLine) {
    if (fullLine) {
        x = (byte) (x | a);
    } else {
        x = (byte) (x & ~a);
    }
}

通過該方法，若a邊為實線，則將a flag的值填入x中，反之擦除掉x中的a邊信息；同時保證其他信息不變。

若要拿，也就是判斷a是否為實線該如何辦？

boolean isFullLine() {
    // return (x & a) != 0;
    return (x & a) == a;
}

2種寫法都是OK的，不過需要注意若對應(yīng)的a使用了符號位則需要使用0xFF先清理自動補(bǔ)充的符號位。因為與、或、非等操作默認(rèn)會將參數(shù)轉(zhuǎn)化為int類型進(jìn)行；所以會出現(xiàn)自動補(bǔ)充符號位的情況。

這樣的操作方案在Android或Socket傳輸中都是非常常見的，比如Socket NIO中的SelectorKey中的ops變量就是這樣的機(jī)制；這能有效減少存儲多個參數(shù)的情況；并且位操作并不會帶來多少計算負(fù)擔(dān)。

以上就是關(guān)于Java 位操作的常見疑問與原理的講解，其實還有一些深入的東西，比如：同余、負(fù)數(shù)取模、小數(shù)、規(guī)律運(yùn)算等；這些因為使用較少并且篇幅有限就等下期再給大家一一介紹了。

我是QIUJUER，關(guān)于我