java的位與
Ⅰ java的位與運算用法
知道位是什麼概念不？就是把兩個數的每一位做與運算，也就是同時為1是結果為1，否則為0；
你的代碼中num1=6,6換成位表示就
是00000110，num2=11，換成位表示是00001011，這兩個位運算，他們的最後一位一個是0，一個是1，那麼結果的最後一位就是0；倒數
第二位都是1那麼結果的倒數第二位就是1，每位如此計算後得到結果為00000010，也就是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中「按位或」和「按位與」怎麼計算啊以4|5、4&5為例你給我講講可以嗎謝謝了！
將十進制數字轉化成二進制，再分別按位與（或）
與：1 1相與為1 、 0與任何數字相與為0
或：1 1相或為1 、1與任何數字相或為1
Ⅳ java中的位運算符的應用和詳細分析啊 急急急！！！！！（具體在什麼方面會比較常用啊）
比如把2變成8
我們可以2*4
效率最高的方法是2<<2
因為2變成二進制是10.00
<<2就是小數點往右移兩位
就變成了1000
十進制就是8
如果2<<3就就是16了
說白了，往左移一位>>1 就是除以2，往右移一位<<1就是乘以2
我自己都說暈了，建議不是高效率運算還是不要用的好，沒那必要
Ⅳ java中按位與和按位或的問題
按位與 &
按位或 |
轉為二進制操作即可
&: 兩位同時為「1」，結果才為「1」，否則為0
|: 參加運算的兩個對象只要有一個為1，其值為1。
按位與：
5: 0000 0101
9: 0000 1001
1: 0000 0001
按位或：
5: 0000 0101
9: 0000 1001
13: 0000 1101
Ⅵ java的位運算
根據你提供的結果判斷，你說的這個「11000011"數，不是二進制，是個十進制吧。
你把11000011化成二進制補碼，然後右移兩位。把結果再轉換為十進制就是「2750002」了。
java中使用補碼表示二進制，正數的補碼是其本身，負數的補碼是它的絕對值取反+1：
例如：
+3 二進制位0000 0011（最高位為符號位，0正，1負），補碼為：0000 0011；
-3 絕對值二進制位0000 0011，求反為1111 1100，補碼為1111 1101
對-3>>2 ===== 1111 1101>>2 結果為1111 1111（為補碼） 化成十進制為-1；
可能說的不夠詳細，僅供參考。。。。
Ⅶ 什麼是Java的位運算符
位運算符用來對二進制位進行操作,位
運
算
符
(＞＞,＜＜,＞＞＞,&,|,^,～
)
,位運
算
符
中
,除
～
以
外
,其餘
均
為
二
元
運
算
符
。
操
作
數
只
能
為
整
型
和字
符
型
數
據
。
比如『>>』
這個就相當於乘以2.
Ⅷ java中的按位與是什麼意思
按位與復是整數運算，整數制以二進制形式，每一位進行與運輸，例如6與7的計算過程，6和7的二進制分別是110、111，進行與運輸要求兩個數都為1結果為，否則結果為0,110與111的結果為110，也就是6與7=6。
看明白了吧，我是不是太羅嗦了點~~~
Ⅸ java位運算符<<和>>還有>>>怎麼用
int i = 2; // 二進制00000010
int n = i<<3; // 左移 n=i*2*2*2;
>>> 無符號右移位，高位永遠填0