深入Java中的位操作

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

• 關於WTF系列

引

學完本章節你將學會位的基礎概念與語法，並且還會一些騷操作！！

• 與、或、非、位移
• 原碼、反碼、補碼
• 字節、位、超區間......

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

byte a = 33;
byte b = -3;

若我們輸出a、b的二進制字符串是多少？

答案是這樣的么？

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

當然同學們可能會覺得我既然問了就肯定不是這樣；是吧～別着急你們試試就知道了。

在Java中輸出一個值對應的二進制方法有很多，這里提供一個簡單的方法：

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

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

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

基本原則

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

簡單來說：

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

默認例子中的值都按byte來算，占8位，減少大家的記憶負擔。

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

• 0 代表正數
• 1 代表負數

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

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

二進制的計算規則是：逢2進1

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

在平時生活中是逢10進1；因為咱們有10個數字：9、8、7、6、5、4、3、2、1、0；所以11就是：當為0|9增加為10的時候就進一格所以變成：1|0，個位再把剩余的1補上就是：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  

運算法則

設

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

按位與 a & b

輸入2個參數

a、b對應位都為1時，c對應位為1；反之為0。

按位或 a | b**

輸入2個參數

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

按位異或 a^b

輸入2個參數

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

按位取反(非)

輸入1個參數

c對應位與輸入參數a完全相反；a對應位為1，則c對應位就為0；a對應位為0，則c對應位就為1。

左移

輸入1個參數a；n = 1

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

右移（帶符號）

輸入1個參數b；n = 1

這里將參數換為b是因為b為負數，第一個位為1

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

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

右移（無符號）

輸入1個參數b；n = 1

這里將參數換為b是因為b為負數，第一個位為1

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

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

進制表示規范

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

前綴

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

后綴

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

范圍

• 二進制：1、0
• 八進制：0～7
• 十進制：0～9
• 十六進制：0～9 + A～F

類型轉換

在上述運算法則中：兩個不同長度的數據進行位運算時，系統會將二者按右端對齊左端補齊，然后進行位運算。

設

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

執行： a&b 、a|b 、a^b….等操作時：

1. 若b為正數，則左邊補齊24個0
2. 若b為負數，則左邊補齊24個1

若b = 0b01011000 補齊后：0b 00000000 00000000 00000000 01011000

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

為什么 b = 0b10101000 需要加上 (byte) 強轉？

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

當強轉 byte 后高位丟棄，保留低8位，對於byte來說低8中的高位就是符號位；所以運算后就是：-88（byte）。

原碼、反碼、補碼

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

我相信大家覺得正數負數就是這樣的：

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

大家可能會想，正數與負數不就應該只是差符號位的變化么？

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

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

在這里我們先設兩個基本的概念：

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

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

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

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

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

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

所以若計算機的機器碼直接采用原碼則會導致硬件資源的設計問題。

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

反碼

• 正數的反碼是其本身
• 負數的反碼是在其原碼的基礎上, 符號位不變，其余各個位取反。可以簡單理解為 "~a | 10000000"

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

如上圖，咱們將 -1 的原碼轉化為了反碼；此時我們使用 反[+1] + 反[-1] 進行一次運算：

此時咱們可以得到一個值x，這個值可以確定的是符號位為1，為負數，后面數據位全部為1；因為此時是反碼狀態，所以要想我們能直接讀取數據是不是應該轉化為原碼狀態啊。

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

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

但上述也暴露一個問題：-0 的問題；對於0的表示將會出現兩種情況：

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

也就是出現兩種為0的表示值，-0與+0；但對於我們來說0就是0，不需要做區分。所以又引入了補碼。

補碼

• 正數與反碼規則一樣無需變化：補碼=反碼=原碼
• 負數在反碼基礎上保證符號位不變，從右端+1

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

此時若計算機使用補碼直接進行計算會怎樣？

當我們使用補碼計算時，因為末尾的兩位均為1，1+1 = 2；對於二進制來說滿2進1，所以往前進位1，進位后又遇到 1+1 = 2的情形，所以依次進位，當前位置0。

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

請注意：在當前運算過程中符號位並無差別也直接當作普通值進行步進運算！

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

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

補碼->原碼

正數的補碼就是原碼

負數：

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

思考[10000000]代表什么？

若是某個計算完成后的補碼值為：10000000 那么他對應的值是什么呢？

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

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

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

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

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

對於正數：

127 = [01111111]原 = [01111111]反 = [01111111]補

對於負數：

-127 = [11111111]原 = [10000000]反 = [10000001]補

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

再次強調：計算機存儲的是補碼，為了方便運算；我們想要理解其表示的值需要轉化為原碼。

溢出問題

因為計算機計算過程中不再區別符號位，直接將符號位也納入運算流程中；所以也就可以解釋2個基礎問題：（溢出）

1. 兩個正數相加為負數
2. 兩個負數相加為正數

大家可以分析一下：

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

上述計算在byte變量范圍下進行計算，嘗試分析一下補碼的計算流程。

存儲區間

默認的對於采用補碼的計算機系統而言，其存儲值的有效范圍是：-2^(n-1) ~ 2^(n-1) -1 ；n代表當前的位數。

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

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

設：

• int i = 200
• 對應補碼為： 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

當我們將200強轉為byte時高位丟棄僅剩下低8位：1100 1000

如果我們對byte進行輸出會怎樣？

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

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

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

首先對於byte b來說：1100 1000 這是一個負數的補碼，其原碼流程是：

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

這里有一個有趣的事情，int轉byte時是直接丟掉高位的所有數據：24個0；但byte轉int時，補充高24位時是根據當前的符號位來補充的，若當前符號位是1則添1，若符號位是0則添0；對於byte來說第一位就是符號位，當前的1100 1000符號位是**“1”**所以添加的就是24位1。

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

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

對於范圍較少的類型轉換位大類型時不會丟失數據，原來是什么就是什么。

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

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

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

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

[1111 1111 1111 1111 1111 1111 1100 1000]補 = -56
[0000 0000 0000 0000 0000 0000 1100 1000]補 = 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 轉換為int之后的值與 0xFF 進行按位與操作。

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

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

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 操作，其值應是：

/*
 * 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 本質來說超過了short的存儲范圍：-32768~32767 ，但其在int中依然只需占2個字節16位：65376<65536。所以我們只需要使用2個byte即可存儲，而不需要int的4個byte來存儲。

在Socket傳輸中使用這樣的方式能有效降低傳輸的字節冗余。

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

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

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

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

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

但是我們表示的內容無非就是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的，不過需要注意若對應的a使用了符號位則需要使用0xFF先清理自動補充的符號位。因為與、或、非等操作默認會將參數轉化為int類型進行；所以會出現自動補充符號位的情況。

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

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

我是QIUJUER，關於我

原文鏈接：https://my.oschina.net/qiujuer/blog/2994957