java中位

『壹』 java中位運算符，(byte) 0x80 的那個，為何答案是-32

0x80 表示 128，（0x 代表 16 進制，8 * 16¹ + 0 * 16º = 128），128 的二進制是 10000000，即 2 的 7 次方。
byte 共有 8 位，表示範圍是 -128 ~ 127，二進制即裂拍亂 10000000 ~ 01111111，第一位為符號位，1 表示負數，0 表示整數，11111111 即表示 -127，10000000 比較特殊，表示 -128。所以，0x80 本來是整數的 128，二進制 （Java 中賀握整數4個位元組32位）。(byte)0x80，肆檔將其轉換為 byte，即截取最後 8 位，即 10000000，就是 byte 中的 -128。
>> 表示右移操作，右移一位表示除以 2。(byte)0x80 >> 2，表示將(byte)0x80右移兩位，那麼就是 -128 ÷ 2 ÷ 2 = -32。

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

java中的位運運算元及其用法。

位邏輯運運算元有「與」（AND）、「或」（OR）、「異或（XOR）」、「非（NOT）」，分別用「&」、「|」、「^」、「~」表示。
下面的例子說明了位邏輯運運算元：
Demonstrate the biise 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[] = {
Ɔ', Ƈ', ƈ', Ɖ', Ɗ', Ƌ', ƌ', ƍ',
Ǝ', Ə', '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[] = {
Ɔ', Ƈ', ƈ', Ɖ', Ɗ', Ƌ', ƌ', ƍ',
Ǝ', Ə', '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
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的位運運算元？

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

c++中的位運運算元號

C++位運運算元有以下兩類：
1 位邏輯運運算元：&（位「與」）、^（位「異或」）、|（位「或」）和~（位「取反」）
2 移位運運算元：<<（左移）和>>(右移).
位「與」、位「或」和位「異或」運運算元都是雙目運運算元，其結合性都是從左向右的，優先順序高於邏輯運運算元，低於比較運運算元，且從高到低依次為&、^、|

c++中按位運運算元的用法

這個是C++中的基礎，你可以看看人家的部落格。
:m.blog.csdn./article/details?id=52196039

java中位運運算元詳解

運運算元那多了去了
算術運運算元 + - * / % 分別是加減乘除求余
在這里要特別注意有個晉升現象.是指低於int的三種類型(byte short char)進行算術運算後會自動提升成int型別列如
byte a=20;
byte b=30;
byte c=a+b;這就錯了應該寫成byte c=(byte)(a+b);或者 int c =a+b;
比較運運算元
即< ,> ,<=, >= ,==, !=分別是小於, 大於, 小於等於,大於等於,不等於
它的結果是一個Boolean 型別
邏輯運運算元
或(||) 與(&&) 非(!) or and not
賦值運運算元
最簡單的是"="用來為常量或者變數指定值注意不能為運算式賦值
還有其他賦值運運算元如下
+= 加等 把變數加上右側的值然後再賦值給自身
-= 減等 把變數減去右側的值然後再賦值給自身
*= 乘等 把變數乘以右側的值然後再賦值給自身
/= 除等 把變數除以右側的值然後再賦值給自身
%= 取余等 把變數和右側的值取余然後再賦值給自身
還有二進位制運運算元
位運運算元
移位運運算元....
++ 遞增
-- 遞減
條件?值1:值2 條件運運算元

java中的邏輯符號，運運算元（位運運算元）個代表什麼

算數運運算元，+-*/(+=，-=，*=，、/*) p.s. 1/0 => NaN 無窮大。邏輯運運算元，略轉義序列符（例舉）， 退格, 製表, 換行（制圖、一般println）, 回車, " 雙引號, ' 單引號p.s. 取決於os，並不常用。遞增/減 ++, --賦值 =比較 >=，<=, ==位移 <<，>>, >>>p.s. 圖形用到注釋， 行注釋，/* */段注釋型別轉換， a = (int)b; 括弧。條件， if()... == a ? true : false 三目運算。正則表示式， 應用類，用到這再說。
LZ是學Java的新手吧。嗯，慢慢學

java都有哪些運運算元及其用法

Java的運運算元可分為4類：算術運運算元、關系運算符、邏輯運運算元和位運運算元。
1.算術運運算元
Java的算術運運算元分為一元運運算元和二元運運算元。一元運運算元只有一個運算元；二元運運算元有兩個運算元，運運算元位於兩個運算元之間。算術運運算元的運算元必須是數值型別。
(1)一元運運算元：
一元運運算元有：正（+）、負（－）、加1（++）和減1（－－）4個。
加1、減1運運算元只允許用於數值型別的變數，不允許用於表示式中。加1、減1運運算元既可放在變數之前（如＋＋i），也可放在變數之後（如i＋＋），兩者的差別是：如果放在變數之前（如＋＋i），則變數值先加1或減1，然後進行其他相應的操作（主要是賦值操作）；如果放在變數之後（如i＋＋），則先進行其他相應的操作，然後再進行變數值加1或減1。
例如：
int i=6，j，k，m，n;
j = +i; 取原值，即j=6
k = -i; 取負值，即k=-6
m = i++; 先m=i,再i=i+1，即m=6，i=7
m = ++i; 先i=i+1,再m=i，即i=7，m=7
n = j--; 先n=j,再j=j-1，即n=6，j=5
n = --j; 先j=j-1,再n=j，即j=5，n=5
在書寫時還要注意的是：一元運運算元與其前後的運算元之間不允許有空格，否則編譯時會出錯。
(2)二元運運算元
二元運運算元有：加（+）、減（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、減、乘、除四則運算，%是求兩個運算元相除後的余數。
%求余操作舉例：
a % b = a － (a / b) * b
取余運運算元既可用於兩個運算元都是整數的情況，也可用於兩個運算元都是浮點數（或一個運算元是浮點數）的情況。當兩個運算元都是浮點數時，例如7.6 % 2.9時，計算結果為：7.6 － 2 * 2.9 = 1.8。
當兩個運算元都是int型別數時，a%b的計算公式為：
a % b = a － （int）(a / b) * b
當兩個運算元都是long型別（或其他整數型別）數時，a%b的計算公式可以類推。
當參加二元運算的兩個運算元的資料型別不同時，所得結果的資料型別與精度較高（或位數更長）的那種資料型別一致。

例如：
7 / 3 整除，運算結果為2
7.0 / 3 除法，運算結果為2.33333,即結果與精度較高的型別一致
7 % 3 取余，運算結果為1
7.0 % 3 取余，運算結果為1.0
-7 % 3 取余，運算結果為-1，即運算結果的符號與左運算元相同
7 % -3 取余，運算結果為1，即運算結果的符號與左運算元相同
2.關系運算符
關系運算符用於比較兩個數值之間的大小，其運算結果為一個邏輯型別的數值。關系運算符有六個：等於（==）、不等於（!=）、大於（>）、大於等於（>=）、小於（<）、小於等於（<=）。

例如：
9 <= 8 運算結果為false
9.9 >= 8.8 運算結果為true
'A' < 'a' 運算結果為true，因字元'A'的Unicode編碼值小於字元'a'的
要說明的是，對於大於等於（或小於等於）關系運算符來說，只有大於和等於兩種關系運算都不成立時其結果值才為false，只要有一種（大於或等於）關系運算成立其結果值即為true。例如，對於9 <= 8，9既不小於8也不等於8，所以9 <= 8 的運算結果為false。對於9 >= 9，因9等於9，所以9 >= 9的運算結果為true。
3.邏輯運運算元
邏輯運運算元要求運算元的資料型別為邏輯型，其運算結果也是邏輯型值。邏輯運運算元有：邏輯與（&&）、邏輯或（||）、邏輯非（!）、邏輯異或（^）、邏輯與（&）、邏輯或（|）。
真值表是表示邏輯運算功能的一種直觀方法，其具體方法是把邏輯運算的所有可能值用表格形式全部羅列出來。Java語言邏輯運運算元的真值表如下：
邏輯運運算元的真值表
A B A&&B A||B !A A^B A&B A|B
false false false false true false false false
true false false true false true false true
false true false true true true false true
true true true true false false true true
前兩列是參與邏輯運算的兩個邏輯變數，共有4種可能，所以表2.5共有4行。後6列分別是6個邏輯運運算元在邏輯變數A和邏輯變數B取不同數值時的運算結果值。
要說明的是，兩種邏輯與（&&和&）的運算規則基本相同，兩種邏輯或（||和|）的運算規則也基本相同。其區別是：&和|運算是把邏輯表示式全部計算完，而&&和||運算具有短路計算功能。所謂短路計算，是指系統從左至右進行邏輯表示式的計算，一旦出現計算結果已經確定的情況，則計算過程即被終止。對於&&運算來說，只要運運算元左端的值為false，則因無論運運算元右端的值為true或為false，其最終結果都為false。所以，系統一旦判斷出&&運運算元左端的值為false，則系統將終止其後的計算過程；對於 || 運算來說，只要運運算元左端的值為true，則因無論運運算元右端的值為true或為false，其最終結果都為true。所以，系統一旦判斷出|| 運運算元左端的值為true，則系統將終止其後的計算過程。

例如，有如下邏輯表示式：
(i>=1) && (i<=100)
此時，若i等於0，則系統判斷出i>=1的計算結果為false後，系統馬上得出該邏輯表示式的最終計算結果為false，因此，系統不繼續判斷i<=100的值。短路計算功能可以提高程式的執行速度。
作者建議讀者：在程式設計時使用&&和||運運算元，不使用&和|運運算元。
用邏輯與（&&）、邏輯或（||）和邏輯非（!）可以組合出各種可能的邏輯表示式。邏輯表示式主要用在 if、while等語句的條件組合上。
例如：
int i = 1;
while(i>=1) && (i<=100) i++; 迴圈過程
上述程式段的迴圈過程將i++語句迴圈執行100次。
4.位運運算元
位運算是以二進位制位為單位進行的運算，其運算元和運算結果都是整型值。
位運運算元共有7個，分別是：位與（&）、位或（|）、位非（~）、位異或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。
位運算的位與（&）、位或（|）、位非（~）、位異或（^）與邏輯運算的相應操作的真值表完全相同，其差別只是位運算操作的運算元和運算結果都是二進位制整數，而邏輯運算相應操作的運算元和運算結果都是邏輯值。

位運算示例
運運算元 名稱 示例 說明
& 位與 x&y 把x和y按位求與
| 位或 x|y 把x和y按位求或
~ 位非 ~x 把x按位求非
^ 位異或 x^y 把x和y按位求異或
>> 右移 x>>y 把x的各位右移y位
<< 左移 x<<y 把x的各位左移y位
>>> 右移 x>>>y 把x的各位右移y位，左邊填0
舉例說明：
（1）有如下程式段：
int x = 64; x等於二進位制數的01000000
int y = 70; y等於二進位制數的01000110
int z = x&y z等於二進位制數的01000000
即運算結果為z等於二進位制數01000000。位或、位非、位異或的運算方法類同。
（2）右移是將一個二進位制數按指定移動的位數向右移位，移掉的被丟棄，左邊移進的部分或者補0（當該數為正時），或者補1（當該數為負時）。這是因為整數在機器內部採用補碼表示法，正數的符號位為0，負數的符號位為1。例如，對於如下程式段：
int x = 70; x等於二進位制數的01000110
int y = 2;
int z = x>>y z等於二進位制數的00010001
即運算結果為z等於二進位制數00010001，即z等於十進位制數17。
對於如下程式段：
int x = -70; x等於二進位制數的11000110
int y = 2;
int z = x>>y z等於二進位制數的11101110
即運算結果為z等於二進位制數11101110，即z等於十進位制數-18。要透徹理解右移和左移操作，讀者需要掌握整數機器數的補碼表示法。
（3）0填充的右移（>>>）是不論被移動數是正數還是負數，左邊移進的部分一律補0。
5.其他運運算元
（1）賦值運運算元與其他運運算元的簡捷使用方式
賦值運運算元可以與二元算術運運算元、邏輯運運算元和位運運算元組合成簡捷運運算元，從而可以簡化一些常用表示式的書寫。
賦值運運算元與其他運運算元的簡捷使用方式
運運算元 用法 等價於 說明
+= s+=i s=s+i s，i是數值型
-= s-=i s=s-i s，i是數值型
*= s*=i s=s*i s，i是數值型
/= s/=i s=s/i s，i是數值型
%= s%=i s=s%i s，i是數值型
&= a&=b a=a&b a，b是邏輯型或整型
|= a|=b a=a|b a，b是邏輯型或整型
^= A^=b a=a^b a，b是邏輯型或整型
<<= s<<=i s=s<<i s，i是整型
>>= s>>=i s=s>>i s，i是整型
>>>= s>>>=i s=s>>>i s，i是整型
（2）方括弧[]和圓括弧（）運運算元
方括弧[]是陣列運運算元，方括弧[]中的數值是陣列的下標，整個表示式就代表陣列中該下標所在位置的元素值。
圓括弧（）運運算元用於改變表示式中運運算元的優先順序。
（3）字串加（+）運運算元
當運算元是字串時，加（+）運運算元用來合並兩個字串；當加（+）運運算元的一邊是字串，另一邊是數值時，機器將自動將數值轉換為字串，這種情況在輸出語句中很常見。如對於如下程式段：
int max = 100;
System.out.println（"max = "+max）;
計算機螢幕的輸出結果為：max = 100，即此時是把變數max中的整數值100轉換成字串100輸出的。
（4）條件運運算元（？：）
條件運運算元（？：）的語法形式為：
<表示式1> ？<表示式2> : <表示式3>
條件運運算元的運算方法是：先計算<表示式1>的值，當<表示式1>的值為true時，則將<表示式2>的值作為整個表示式的值；當<表示式1>的值為false時，則將<表示式3>的值作為整個表示式的值。如：
int a=1，b=2，max;
max = a>b？a：b; max等於2
（5）強制型別轉換符
強制型別轉換符能將一個表示式的型別強制轉換為某一指定資料型別，其語法形式為：
(<型別>)<表示式>
（6）物件運運算元instanceof
物件運運算元instanceof用來測試一個指定物件是否是指定類（或它的子類）的例項，若是則返回true，否則返回false。
（7）點運運算元
點運運算元「.」的功能有兩個：一是引用類中成員，二是指示包的層次等級。

6.運運算元的優先順序
以下按優先順序從高到低的次序列出Java語言中的所有運運算元，表中結合性一列中的「左右」表示其運算次序為從左向右，「右左」表示其運算次序為從右向左。
優先順序 運運算元 結合性
1 . [] () ; ,
2 ++ ―― += ! ~ +(一元) -(一元) 右左
3 * / % 左右
4 +(二元) -(二元) 左右
5 << >> >>> 左右
6 < > <= >= instanceof 左右
7 = = != 左右
8 & 左右
9 ^ 左右
10 | 左右
11 && 左右
12 || 左右
13 ?： 右左
14 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右左
--感謝原作者。

如何理解vba中邏輯運運算元的位運運算元

位運運算元並不是邏輯運運算元，邏輯運運算元包括或、與、非、異或。

『叄』 java語言中 位運算符怎麼計算的

都轉換成16進制，就好處理
00000000 00000000 00000000 00010011
00000000 00000000 00000000 00010100
結果
00000000 00000000 00000000 00010000
只有兩個位都是1，結果的位才是1 。

『肆』 java中位運算符的優先順序

指針最優，單目運算優於雙目運算。如正負號。
先乘除（模），後加減。
先算術運算，後移位運算，最後位運算。請特別注意：1 << 3 + 2 & 7等價於 (1 << (3 + 2))&7.
邏輯運算最後計算。

『伍』 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 如何求多個數的中位數 具體！！！

package com.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
System.out.println(zhongweishu(7, 4, 8));
}
// 可換為多個數，如參數為：int a,int b,int c,int d,int e
public static int zhongweishu(int a, int b, int c){
int[] nums = {a,b,c};
Arrays.sort(nums); // 數組彎友從小到大排序液塵
return nums[nums.length/2]; /鬧鬧禪/ 找出排序後中間的數組值
}
}