深入理解Java中的位操作
與、或、非、位移
原碼、反碼、補碼
字節、位、超區間......
開始本章節之前，我們先思考一個問題：
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….等操作時：
若b為正數，則左邊補齊24個0
若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-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即可）【敲黑板】
思考[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個基礎問題：（溢出）兩個正數相加為負數
兩個負數相加為正數
大家可以分析一下：
88+100
(-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入門教學資源。幫助大家在成為Java架構師的道路上披荊斬棘。需要資料的歡迎加入學習交流群：9285，05736
創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎總結
以上是生活随笔為你收集整理的深入理解Java中的位操作的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： JAVA四种遍历Map的方法
- 下一篇： 看Java大牛是如何高效学习的？你掌握好