java位

『壹』 java中四個二進制位從操作符即（&按位與、|按位貨、^按位異或、~按位取反）

首先回答你問的問題：
按位與運算符（&）
參加運算的兩個數據，按二進制位進行「與」運算。

運算規則：0&0=0; 0&1=0; 1&0=0; 1&1=1;

即：兩位同時為「1」，結果才為「1」，否則為0

例如：3&5 即 0000 0011 & 0000 0101 = 0000 0001 因此，3&5的值得1。

另，負數按補碼形式參加按位與運算。

「與運算」的特殊用途：

（1）清零。如果想將一個單元清零，即使其全部二進制位為0，只要與一個各位都為零的數值相與，結果為零。

（2）取一個數中指定位

方法：找一個數，對應X要取的位，該數的對應位為1，其餘位為零，此數與X進行「與運算」可以得到X中的指定位。

例：設X=10101110，

取X的低4位，用 X & 0000 1111 = 0000 1110 即可得到；

還可用來取X的2、4、6位。

按位或運算符（|）
參加運算的兩個對象，按二進制位進行「或」運算。

運算規則：0|0=0； 0|1=1； 1|0=1； 1|1=1；

即 ：參加運算的兩個對象只要有一個為1，其值為1。

例如:3|5 即 0000 0011 | 0000 0101 = 0000 0111 因此，3|5的值得7。

另，負數按補碼形式參加按位或運算。

「或運算」特殊作用：

（1）常用來對一個數據的某些位置1。

方法：找到一個數，對應X要置1的位，該數的對應位為1，其餘位為零。此數與X相或可使X中的某些位置1。

例：將X=10100000的低4位置1 ，用 X | 0000 1111 = 1010 1111即可得到。

異或運算符（^）
參加運算的兩個數據，按二進制位進行「異或」運算。

運算規則：0^0=0； 0^1=1； 1^0=1； 1^1=0；

即：參加運算的兩個對象，如果兩個相應位為「異」（值不同），則該位結果為1，否則為0。

「異或運算」的特殊作用：

（1）使特定位翻轉找一個數，對應X要翻轉的各位，該數的對應位為1，其餘位為零，此數與X對應位異或即可。

例：X=10101110，使X低4位翻轉，用X ^ 0000 1111 = 1010 0001即可得到。

（2）與0相異或，保留原值 ，X ^ 0000 0000 = 1010 1110。

從上面的例題可以清楚的看到這一點。

取反運算符（~）
參加運算的一個數據，按二進制位進行「取反」運算。

運算規則：~1=0； ~0=1；

即：對一個二進制數按位取反，即將0變1，1變0。

使一個數的最低位為零，可以表示為：a&~1。

~1的值為1111111111111110，再按「與」運算，最低位一定為0。因為「~」運算符的優先順序比算術運算符、關系運算符、邏輯運算符和其他運算符都高。

然後在附送你兩個為運算符的解釋：
左移運算符（<<）
將一個運算對象的各二進制位全部左移若干位（左邊的二進制位丟棄，右邊補0）。

例：a = a << 2 將a的二進制位左移2位，右補0，

左移1位後a = a * 2;
若左移時舍棄的高位不包含1，則每左移一位，相當於該數乘以2。

右移運算符（>>）
將一個數的各二進制位全部右移若干位，正數左補0，負數左補1，右邊丟棄。

操作數每右移一位，相當於該數除以2。

例如：a = a >> 2 將a的二進制位右移2位，

左補0 or 補1 得看被移數是正還是負。

如果還有什麼疑問，可以參考一下參考資料

希望我的回答對您有幫助，別忘了採納答案哦~

『貳』 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語言中，位運算符使用中，數的「位」是什麼

與運算 法則 0&0=0;0&1=0;1&0=0;1&1=1 位就是十進制裡面的個十百千 萬，其它的進制也一樣。129&128先轉換成2進制再依次從低位算到高位，結果又轉換成十進制。就是128，那個答案很詳細了，你首先得了解幾種所熟悉的位運算。
就是 與 或 非 。。。當然這屬於邏輯運算，還有好多與或，異或，你可以網路看一下。。。

『肆』 java中的按位運算符

與
0&&0 =0
1&&0 =0
0&&1 =0
1&&1 =1
或
0||0 =0
1||0 =1
0||1 =1
1||1 =1
異或是
1^0=1
0^1=1
0^0=0
1^1=0

例子
11001010 與
00011011
按位與 按位或 按位異或
00001010 11011011 11010001

『伍』 關於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中兩種不同的分離十位、個位的方式
//獲取最高位（百位）
b = a / 100;
獲取十位c=(a%100)/10; 或者c = (a / 10) % 10;
獲取個位d=a%10; 或者 d = a % 100 % 10;

『柒』 java 按位運算

你的這個設計有問題。

位運算來進行邏輯判斷，其實就是用數字的二進制各位來做標志。通過位運算，進行許可權的組合和拆分。

這樣有個基礎：就是每個許可權的值正好要是二進制位的對應值。
許可權可以取的數就是二進制的進度值。如：1,2,4,8,16,32……(不超過數字表達范圍）。

看你的題目: 3是發帖，4是刪帖。要用二進制來做掩碼計算。設計不科學。

兩個方法：
1 建議使用1，2，4，8……來定義的你的許可權。
如果改成：4是發帖，8是刪帖
long power=4|8;
判斷是否有發帖許可權：power&4 >0

2 如果一定要用1，2，3，4來定義，那麼要做進制操作。
long power=(1<<(3-1))|(1<<(4-1));
判斷是否有發帖許可權：(power&(1<<(3-1))) > 0

註：如果上面都不減去1，也行，就浪費一個位置。

『捌』 java位運算符<<和>>還有>>>怎麼用

左移<<
右移>> 和>>>
二進制的數，其中，對於>>>無論整數還是負數，最高位都補0
就這個區別而已，
還有一個結論是移動了n就相當於左移（乘）、右移（除）2的n次冪
比如：
16>>3等效於16除2的3次方，

『玖』 java中的分離十位、個位的方式

java中兩種不同的分離十位、個位的方式
//獲取最高位（百位）
b = a / 100;
獲取十位c=(a%100)/10; 或者c = (a / 10) % 10;
獲取個位d=a%10; 或者 d = a % 100 % 10;

『拾』 java中的按位與是什麼意思

按位與是整數運算，整數以二進制形式，每一位進行與運輸，例如6與7的計算過程，6和7的二進制分別是110、111，進行與運輸要求兩個數都為1結果為，否則結果為0,110與111的結果為110，也就是6與7=6。

看明白了吧，我是不是太羅嗦了點~~~