java位運算

『壹』 java里,位運算&,│,^,是怎麼用的

位運算主要用在一些特殊的為了節約內存的場合，在這種情況下，多個邏輯變數被合並到一個變數當中，分別占據一個變數的不同位，這個時候就需要用位運算來判斷邏輯變數的值了
移位主要可以用在計算*2，/2這樣的運算，當然，還有一些演算法可能會涉及移位運算
無符號數，如果需要表示的數字比有符號的稍微大一點點，同時又知道那個數字不可能為負就可以用無符號數，例如學生編號，等

『貳』 java中的位運算符及其用法。

位邏輯運算符有「與」（AND）、「或」（OR）、「異或（XOR）」、「非（NOT）」，分別用「&」、「|」、「^」、「~」表示。

下面的例子說明了位邏輯運算符：

// Demonstrate the bitwise logical operators.

class BitLogic {

public static void main(String args[]) {

String binary[] = {

"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",

"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"

};

int a = 3; // 0 + 2 + 1 or 0011 in binary

int b = 6; // 4 + 2 + 0 or 0110 in binary

int c = a | b;

int d = a & b;

int e = a ^ b;

int f = (~a & b) | (a & ~b);

int g = ~a & 0x0f;

System.out.println(" a = " + binary[a]);

System.out.println(" b = " + binary[b]);

System.out.println(" a|b = " + binary[c]);

System.out.println(" a&b = " + binary[d]);

System.out.println(" a^b = " + binary[e]);

System.out.println("~a&b|a&~b = " + binary[f]);

System.out.println(" ~a = " + binary[g]);

}

}

在本例中，變數a與b對應位的組合代表了二進制數所有的 4 種組合模式：0-0，0-1，1-0，和1-1。「|」運算符和「&」運算符分別對變數a與b各個對應位的運算得到了變數c和變數d的值。對變數e和f的賦值說明了「^」運算符的功能。字元串數組binary代表了0到15對應的二進制的值。在本例中，數組各元素的排列順序顯示了變數對應值的二進制代碼。數組之所以這樣構造是因為變數的值n對應的二進制代碼可以被正確的存儲在數組對應元素binary[n]中。例如變數a的值為3，則它的二進制代碼對應地存儲在數組元素binary[3]中。~a的值與數字0x0f （對應二進制為0000 1111）進行按位與運算的目的是減小~a的值，保證變數g的結果小於16。因此該程序的運行結果可以用數組binary對應的元素來表示。該程序的輸出如下：

a = 0011

b = 0110

a|b = 0111

a&b = 0010

a^b = 0101

~a&b|a&~b = 0101

~a = 1100

左移運算符

左移運算符<<使指定值的所有位都左移規定的次數。它的通用格式如下所示：

value << num

這里，num指定要移位值value移動的位數。也就是，左移運算符<<使指定值的所有位都左移num位。每左移一個位，高階位都被移出（並且丟棄），並用0填充右邊。這意味著當左移的運算數是int類型時，每移動1位它的第31位就要被移出並且丟棄；當左移的運算數是long類型時，每移動1位它的第63位就要被移出並且丟棄。

在對byte和short類型的值進行移位運算時，你必須小心。因為你知道Java在對表達式求值時，將自動把這些類型擴大為 int型，而且，表達式的值也是int型 。對byte和short類型的值進行移位運算的結果是int型，而且如果左移不超過31位，原來對應各位的值也不會丟棄。但是，如果你對一個負的byte或者short類型的值進行移位運算，它被擴大為int型後，它的符號也被擴展。這樣，整數值結果的高位就會被1填充。因此，為了得到正確的結果，你就要舍棄得到結果的高位。這樣做的最簡單辦法是將結果轉換為byte型。下面的程序說明了這一點：

// Left shifting a byte value.

class ByteShift {

public static void main(String args[]) {

byte a = 64, b;

int i;

i = a << 2;

b = (byte) (a << 2);

System.out.println("Original value of a: " + a);

System.out.println("i and b: " + i + " " + b);

}

}

該程序產生的輸出下所示：

Original value of a: 64

i and b: 256 0

因變數a在賦值表達式中，故被擴大為int型，64（0100 0000）被左移兩次生成值256（10000 0000）被賦給變數i。然而，經過左移後，變數b中惟一的1被移出，低位全部成了0，因此b的值也變成了0。

既然每次左移都可以使原來的操作數翻倍，程序員們經常使用這個辦法來進行快速的2的乘法。但是你要小心，如果你將1移進高階位（31或63位），那麼該值將變為負值。下面的程序說明了這一點：

// Left shifting as a quick way to multiply by 2.

class MultByTwo {

public static void main(String args[]) {

int i;

int num = 0xFFFFFFE;

for(i=0; i<4; i++) {

num = num << 1;

System.out.println(num);

}

}

}

該程序的輸出如下所示：

536870908

1073741816

2147483632

-32

初值經過仔細選擇，以便在左移 4 位後，它會產生-32。正如你看到的，當1被移進31位時，數字被解釋為負值。

右移運算符

右移運算符>>使指定值的所有位都右移規定的次數。它的通用格式如下所示：

value >> num

這里，num指定要移位值value移動的位數。也就是，右移運算符>>使指定值的所有位都右移num位。

下面的程序片段將值32右移2次，將結果8賦給變數a:

int a = 32;

a = a >> 2; // a now contains 8

當值中的某些位被「移出」時，這些位的值將丟棄。例如，下面的程序片段將35右移2次，它的2個低位被移出丟棄，也將結果8賦給變數a:

int a = 35;

a = a >> 2; // a still contains 8

用二進製表示該過程可以更清楚地看到程序的運行過程：

00100011 35

>> 2

00001000 8

將值每右移一次，就相當於將該值除以2並且舍棄了余數。你可以利用這個特點將一個整數進行快速的2的除法。當然，你一定要確保你不會將該數原有的任何一位移出。

右移時，被移走的最高位（最左邊的位）由原來最高位的數字補充。例如，如果要移走的值為負數，每一次右移都在左邊補1，如果要移走的值為正數，每一次右移都在左邊補0，這叫做符號位擴展（保留符號位）（sign extension），在進行右移操作時用來保持負數的符號。例如，–8 >> 1 是–4，用二進製表示如下：

11111000 –8

>>1

11111100 –4

一個要注意的有趣問題是，由於符號位擴展（保留符號位）每次都會在高位補1，因此-1右移的結果總是–1。有時你不希望在右移時保留符號。例如，下面的例子將一個byte型的值轉換為用十六進製表示。注意右移後的值與0x0f進行按位與運算，這樣可以舍棄任何的符號位擴展，以便得到的值可以作為定義數組的下標，從而得到對應數組元素代表的十六進制字元。

// Masking sign extension.

class HexByte {

static public void main(String args[]) {

char hex[] = {

'0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f''

};

byte b = (byte) 0xf1;

System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);

}

}

該程序的輸出如下：

b = 0xf1

無符號右移

正如上面剛剛看到的，每一次右移，>>運算符總是自動地用它的先前最高位的內容補它的最高位。這樣做保留了原值的符號。但有時這並不是我們想要的。例如，如果你進行移位操作的運算數不是數字值，你就不希望進行符號位擴展（保留符號位）。當你處理像素值或圖形時，這種情況是相當普遍的。在這種情況下，不管運算數的初值是什麼，你希望移位後總是在高位（最左邊）補0。這就是人們所說的無符號移動（unsigned shift）。這時你可以使用Java的無符號右移運算符>>>，它總是在左邊補0。下面的程序段說明了無符號右移運算符>>>。在本例中，變數a被賦值為-1，用二進製表示就是32位全是1。這個值然後被無符號右移24位，當然它忽略了符號位擴展，在它的左邊總是補0。這樣得到的值255被賦給變數a。

int a = -1;

a = a >>> 24;

下面用二進制形式進一步說明該操作：

11111111 11111111 11111111 11111111 int型- 1的二進制代碼

>>> 24 無符號右移24位

00000000 00000000 00000000 11111111 int型255的二進制代碼由於無符號右移運算符>>>只是對32位和64位的值有意義，所以它並不像你想像的那樣有用。因為你要記住，在表達式中過小的值總是被自動擴大為int型。這意味著符號位擴展和移動總是發生在32位而不是8位或16位。這樣，對第7位以0開始的byte型的值進行無符號移動是不可能的，因為在實際移動運算時，是對擴大後的32位值進行操作。下面的例子說明了這一點：

// Unsigned shifting a byte value.

class ByteUShift {

static public void main(String args[]) {

char hex[] = {

'0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'

};

byte b = (byte) 0xf1;

byte c = (byte) (b >> 4);

byte d = (byte) (b >>> 4);

byte e = (byte) ((b & 0xff) >> 4);

System.out.println(" b = 0x"

+ hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);

System.out.println(" b >> 4 = 0x"

+ hex[(c >> 4) & 0x0f] + hex[c & 0x0f]);

System.out.println(" b >>> 4 = 0x"

+ hex[(d >> 4) & 0x0f] + hex[d & 0x0f]);

System.out.println("( b & 0xff) >> 4 = 0x"

+ hex[(e >> 4) & 0x0f] + hex[e & 0x0f]);

}

}

該程序的輸出顯示了無符號右移運算符>>>對byte型值處理時，實際上不是對byte型值直接操作，而是將其擴大到int型後再處理。在本例中變數b被賦為任意的負byte型值。對變數b右移4位後轉換為byte型，將得到的值賦給變數c，因為有符號位擴展，所以該值為0xff。對變數b進行無符號右移4位操作後轉換為byte型，將得到的值賦給變數d，你可能期望該值是0x0f，但實際上它是0xff，因為在移動之前變數b就被擴展為int型，已經有符號擴展位。最後一個表達式將變數b的值通過按位與運算將其變為8位，然後右移4位，然後將得到的值賦給變數e，這次得到了預想的結果0x0f。由於對變數d（它的值已經是0xff）進行按位與運算後的符號位的狀態已經明了，所以注意，對變數d再沒有進行無符號右移運算。

B = 0xf1

b >> 4 = 0xff

b >>> 4 = 0xff

(b & 0xff) >> 4 = 0x0f

位運算符賦值

所有的二進制位運算符都有一種將賦值與位運算組合在一起的簡寫形式。例如，下面兩個語句都是將變數a右移4位後賦給a：

a = a >> 4;

a >>= 4;

同樣，下面兩個語句都是將表達式a OR b運算後的結果賦給a：

a = a | b;

a |= b;

下面的程序定義了幾個int型變數，然後運用位賦值簡寫的形式將運算後的值賦給相應的變數：

class OpBitEquals {

public static void main(String args[]) {

int a = 1;

int b = 2;

int c = 3;

a |= 4;

b >>= 1;

c <<= 1;

a ^= c;

System.out.println("a = " + a);

System.out.println("b = " + b);

System.out.println("c = " + c);

}

}

該程序的輸出如下所示：

a = 3

b = 1

c = 6

『叄』 Java中位運算符的具體應用是什麼，在實際編程中有什麼作用

位邏輯運算符有「與」（AND）、「或」（OR）、「異或（XOR）」、「非（NOT）」，分別用「&」、「|」、「^」、「~」表示。
下面的例子說明了位邏輯運算符：
//
Demonstrate
the
bitwise
logical
operators.
class
BitLogic
{
public
static
void
main(String
args[])
{
String
binary[]
=
{
"0000",
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
"1111"
};
int
a
=
3;
//
0
+
2
+
1
or
0011
in
binary
int
b
=
6;
//
4
+
2
+
0
or
0110
in
binary
int
c
=
a
|
b;
int
d
=
a
&
b;
int
e
=
a
^
b;
int
f
=
(~a
&
b)
|
(a
&
~b);
int
g
=
~a
&
0x0f;
System.out.println("
a
=
"
+
binary[a]);
System.out.println("
b
=
"
+
binary[b]);
System.out.println("
a|b
=
"
+
binary[c]);
System.out.println("
a&b
=
"
+
binary[d]);
System.out.println("
a^b
=
"
+
binary[e]);
System.out.println("~a&b|a&~b
=
"
+
binary[f]);
System.out.println("
~a
=
"
+
binary[g]);
}
}
在本例中，變數a與b對應位的組合代表了二進制數所有的
4
種組合模式：0-0，0-1，1-0，和1-1。「|」運算符和「&」運算符分別對變數a與b各個對應位的運算得到了變數c和變數d的值。對變數e和f的賦值說明了「^」運算符的功能。字元串數組binary代表了0到15對應的二進制的值。在本例中，數組各元素的排列順序顯示了變數對應值的二進制代碼。數組之所以這樣構造是因為變數的值n對應的二進制代碼可以被正確的存儲在數組對應元素binary[n]中。例如變數a的值為3，則它的二進制代碼對應地存儲在數組元素binary[3]中。~a的值與數字0x0f
（對應二進制為0000
1111）進行按位與運算的目的是減小~a的值，保證變數g的結果小於16。因此該程序的運行結果可以用數組binary對應的元素來表示。

『肆』 JAVA位運算符

位操作符（bitwise operator）
位操作符允許我們操作一個基本數據類型中的整數型值的單個「比特（bit）」，即二進制位。
位操作符會對兩個參數對應的位執行布爾代數運算，並最終生成一個結果。

位操作符來源於 C 語言面向底層的操作，那時我們經常需要直接操縱硬體，設置硬體寄存
器內的二進制位。Java的設計初衷是嵌入電視機頂盒內，所以這種低級操作仍被保留了下來。
但是，我們可能不會過多地使用到位運算符。

如果兩個輸入位都是 1，則按位「與」操作符（&）生成一個輸出位 1；否則生成一個輸出
位0。如果兩個輸入位里只要有一個是1，則按位「或」操作符（|）生成一個輸出位1；只
有在兩個輸入位都是0的情況下，它才會生成一個輸出位0。如果兩個輸入位的某一個是1，
但不全都是1，那麼「異或」操作（^）生成一個輸出位1。按位「非」（~ ，也稱為取補運
算，ones compliement operator ）屬於一元操作符；它只對一個操作數進行操作（其他位操
作是二元運算）。按位「非」生成與輸入位相反的值——若輸入0，則輸出1；輸入1，則輸
出0。

位操作符和邏輯操作符都使用了同樣的符號。因此，我們能方便地記住它們的含義：由於「位」
是非常「小」的，所以位操作符僅使用了一位符號。

位操作符可與等號（=）聯合使用，以便合並運算操作和賦值操作：&=，|=和^=都是合法
的（由於~是一元操作符，所以不可與=聯合使用）。

我們將布爾類型（boolean）作為一種「單比特」值對待，所以它多少有些獨特的地方。我們

可對它執行按位「與」、「或」和「異或」運算，但不能執行按位「非」（大概是為了避免與
邏輯 NOT 混淆）。對於布爾值，位操作符具有與邏輯操作符相同的效果，只是它們不會中
途「短路」。此外，針對布爾值進行的按位運算為我們新增了一個「異或」邏輯操作符，它並
未包括在「邏輯」操作符的列表中。在移位表達式中，我們被禁止使用布爾運算，原因將在下
面解釋。

移位操作符（shift operator）
移位操作符操作的運算對象也是二進制的「位」，但是它們只可以被用來處理整數類型（基本
類型的一種）。左移位操作符（<<）能將操作符左邊的運算對象向左移動操作符右側指定的
位數（在低位補 0）。「有符號」右移位操作符（>>）則將操作符左邊的運算對象向右移動操
作符右側指定的位數。「有符號」右移位操作符使用了「符號擴展」：若符號為正，則在高位插
入0；若符號為負，則在高位插入1。Java中增加了一種「無符號」右移位操作符（>>>），它
使用了「零擴展」：無論正負，都在高位插入0。這一操作符是C或C++沒有的。

如果對char、byte或者short類型的數值進行移位處理，那麼在移位進行之前，它們會自動
轉換為int，並且得到的結果也是一個int類型的值。而右側操作數，作為真正移位的位數，
只有其二進製表示中的低5位才有用。這樣可防止我們移位超過int型值所具有的位數。（譯
註：因為2的5次方為32，而int型值只有32位）。若對一個long類型的數值進行處理，
最後得到的結果也是long。此時只會用到右側操作數的低6位，以防止移位超過long型數
值具有的位數。

移位可與等號（<<=或>>=或>>>=）組合使用。此時，操作符左邊的值會移動由右邊的值指
定的位數，再將得到的結果賦回左邊的變數。但在進行「無符號」右移結合賦值操作時，可能
會遇到一個問題：如果對byte或short值進行這樣的移位運算，得到的可能不是正確的結果。
它們會先被轉換成int類型，再進行右移操作。然後被截斷，賦值給原來的類型，在這種情
況下可能得到-1的結果。下面這個例子演示了這種情況：

//: c03:URShift.java
// Test of unsigned right shift.
import com.bruceeckel.simpletest.*;

public class URShift {
static Test monitor = new Test();
public static void main(String[] args) {
int i = -1;
System.out.println(i >>>= 10);
long l = -1;
System.out.println(l >>>= 10);
short s = -1;
System.out.println(s >>>= 10);
byte b = -1;
System.out.println(b >>>= 10);

b = -1;
System.out.println(b>>>10);
monitor.expect(new String[] {
"4194303",
"18014398509481983",
"-1",
"-1",
"4194303"
});
}
} ///:~

在最後一個移位運算中，結果沒有賦回給b，而是直接列印出來，所以其結果是正確的。

下面這個例子向大家闡示了如何應用涉及「按位」操作的所有操作符：

//: c03:BitManipulation.java
// Using the bitwise operators.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class BitManipulation {
static Test monitor = new Test();
public static void main(String[] args) {
Random rand = new Random();
int i = rand.nextInt();
int j = rand.nextInt();
printBinaryInt("-1", -1);
printBinaryInt("+1", +1);
int maxpos = 2147483647;
printBinaryInt("maxpos", maxpos);
int maxneg = -2147483648;
printBinaryInt("maxneg", maxneg);
printBinaryInt("i", i);
printBinaryInt("~i", ~i);
printBinaryInt("-i", -i);
printBinaryInt("j", j);
printBinaryInt("i & j", i & j);
printBinaryInt("i | j", i | j);
printBinaryInt("i ^ j", i ^ j);
printBinaryInt("i << 5", i << 5);
printBinaryInt("i >> 5", i >> 5);
printBinaryInt("(~i) >> 5", (~i) >> 5);
printBinaryInt("i >>> 5", i >>> 5);

printBinaryInt("(~i) >>> 5", (~i) >>> 5);

long l = rand.nextLong();
long m = rand.nextLong();
printBinaryLong("-1L", -1L);
printBinaryLong("+1L", +1L);
long ll = 9223372036854775807L;
printBinaryLong("maxpos", ll);
long lln = -9223372036854775808L;
printBinaryLong("maxneg", lln);
printBinaryLong("l", l);
printBinaryLong("~l", ~l);
printBinaryLong("-l", -l);
printBinaryLong("m", m);
printBinaryLong("l & m", l & m);
printBinaryLong("l | m", l | m);
printBinaryLong("l ^ m", l ^ m);
printBinaryLong("l << 5", l << 5);
printBinaryLong("l >> 5", l >> 5);
printBinaryLong("(~l) >> 5", (~l) >> 5);
printBinaryLong("l >>> 5", l >>> 5);
printBinaryLong("(~l) >>> 5", (~l) >>> 5);
monitor.expect("BitManipulation.out");
}
static void printBinaryInt(String s, int i) {
System.out.println(
s + ", int: " + i + ", binary: ");
System.out.print(" ");
for(int j = 31; j >= 0; j--)
if(((1 << j) & i) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.println();
}
static void printBinaryLong(String s, long l) {
System.out.println(
s + ", long: " + l + ", binary: ");
System.out.print(" ");
for(int i = 63; i >= 0; i--)
if(((1L << i) & l) != 0)
System.out.print("1");
else
System.out.print("0");

System.out.println();
}
} ///:~

程序末尾調用了兩個方法：printBinaryInt()和printBinaryLong()。它們分別接受
一個 int 或 long 值的參數，並用二進制格式輸出，同時附有簡要的說明文字。你可以暫
時忽略它們具體是如何實現的。

請注意這里是用 System.out.print()，而不是 System.out.println()。print()方法不自動換行，所
以我們能在同一行里輸出多個信息。

上面的例子中，expect() 以一個文件名作參數，它會從這個文件中讀取預期的行（其中
可以有，也可以沒有正則表達式）。對於那些太長，不適宜列在書里的輸出，這種做法很有
用。這個文件的擴展名是「.out」，是所發布的代碼的一部分，可以從www.BruceEckel.com下
載。如果有興趣的話，可以打開這個文件，看看正確的輸出應該是什麼（或者你自己直接運
行一下前面這個程序）。

上面的例子展示了對int和long的所有按位運算的效果，還展示了int和long的最小值、最
大值、+1和-1值，以及它們的二進制形式，以使大家了解它們在機器中的具體形式。注意，
最高位表示符號：0為正，1為負。下面列出例子中關於int部分的輸出：

-1, int: -1, binary:

+1, int: 1, binary:

maxpos, int: 2147483647, binary:

maxneg, int: -2147483648, binary:

i, int: 59081716, binary:

~i, int: -59081717, binary:

-i, int: -59081716, binary:

j, int: 198850956, binary:

i & j, int: 58720644, binary:

i | j, int: 199212028, binary:

i ^ j, int: 140491384, binary:

i << 5, int: 1890614912, binary:


i >> 5, int: 1846303, binary:

(~i) >> 5, int: -1846304, binary:

i >>> 5, int: 1846303, binary:

(~i) >>> 5, int: 132371424, binary:


數字的二進製表示形式被稱為「有符號的2的補碼」。

『伍』 java 位運算

我的分析是建立在A、B、C三步彼此獨立的情況下：

int b1 = 1; b1在計算機的二進制為0000 0000 0000 0000 0000 0000 0000 0001
int b2 = -1；b2在計算機的二進制為 1111 1111 1111 1111 1111 1111 1111 1111
>> 和 << 是算術位移符，>>>是邏輯位移符
算術位移符和邏輯位移符的區別是：右移時，算術位移左邊補符號位，邏輯位移左邊補0；左移時，二者沒有區別，都是在右邊補0。
b1 <<= 31 ==> 0000 0000 0000 0000 0000 0000 0000 0001 << 31 ==> 1000 0000 0000 0000 0000 0000 0000 0000 ==> -2147483648
b1 >>= 31 ==> 0000 0000 0000 0000 0000 0000 0000 0001 >> 31 ==> 0000 0000 0000 0000 0000 0000 0000 0000 ==> 0
b2 <<= 31 ==> 1111 1111 1111 1111 1111 1111 1111 1111 << 31 ==> 1000 0000 0000 0000 0000 0000 0000 0000 ==> -2147483648
b2 >>= 31 ==> 1111 1111 1111 1111 1111 1111 1111 1111 >> 31 ==> 1111 1111 1111 1111 1111 1111 1111 1111 ==> -1
b1 >>>= 31 ==> 0000 0000 0000 0000 0000 0000 0000 0001 >>> 31 ==> 0000 0000 0000 0000 0000 0000 0000 0000 ==> 0
b2 >>>= 31 ==> 1111 1111 1111 1111 1111 1111 1111 1111 >>> 31 ==> 0000 0000 0000 0000 0000 0000 0000 0001 ==> 1

『陸』 java位運算的用法，高手看看啊

代碼太長不太想看。。。計算機底層都是二進制，所以對於"主要用於移動二進制位置還是做計算用的啊？"這個問題，我覺得可以認為移動二進制位置就是做計算，是一回事，位運算的優點就是：
速度快：比正常+ - * / %等算術運算在運行速度上快，因為是直接操作二進制值，沒有其他上層邏輯處理，比如除以2的結果，/2或者用右移一位>>1的辦法都可以得到，位運算會快些；
節省空間：比如當你的信息用一個位就可以表示的話，那一個位元組可以存儲八個這樣的信息。

不過對於java來講，這個語言一般都應用於注重生產效率而非運行效率的項目上，所以位運算在java項目中不是特別注重，一般是C語言的底層項目或和硬體交互的嵌入式項目會比較多用

『柒』 什麼是Java的位運算符

位運算符用來對二進制位進行操作,位
運
算
符
(＞＞,＜＜,＞＞＞,&,|,^,～
)
,位運
算
符
中
,除
～
以
外
,其餘
均
為
二
元
運
算
符
。
操
作
數
只
能
為
整
型
和字
符
型
數
據
。
比如『>>』
這個就相當於乘以2.

『捌』 關於JAVA的位運算

～是取反運算

首先，你要知道java中的int是32位的
其次，正數以原碼的形式存儲，負數以補碼的形式存儲
4的二進制是0000 0000 0000 0000 0000 0000 0000 0100

取反後得1111 1111 1111 1111 1111 1111 1111 1011

java中都是有符號數，首位是1，所以是負數，負數也就是補碼，也就是說
1111 1111 1111 1111 1111 1111 1111 1011是補碼
補碼，反碼加1後得源碼
轉換成源碼得0000 0000 0000 0000 0000 0000 0000 0101
這個數是5，加上符號就是-5

『玖』 請教java位運算問題

Java 位運算 Java 位運算[轉]一，Java 位運算1.表示方法： 在Java語言中，二進制數使用補碼表示，最高位為符號位，正數的符號位為0，負數為1。補碼的表示需要滿足如下要求。 (l)正數的最高位為0，其餘各位代表數值本身(二進制數)。 (2)對於負數，通過對該數絕對值的補碼按位取反，再對整個數加1。2.位運算符 位運算表達式由操作數和位運算符組成，實現對整數類型的二進制數進行位運算。位運算符可以分為邏輯運算符(包括~、＆、|和^)及移位運算符(包括>>、>)。1)左移位運算符（）則將運算符左邊的運算對象向右移動運算符右側指定的位數。「有符號」右移位運算符使用了「符號擴展」：若值為正，則在高位插入0；若值為負，則在高位插入1。3)Java也添加了一種「無符號」右移位運算符（>>>），它使用了「零擴展」：無論正負，都在高位插入0。這一運算符是C或C++沒有的。