java的運算符，分為四類：
算數運算符、關系運算符、邏輯運算符、位運算符。
算數運算符(9)：+ - * / % ++ --
關系運算符(6)：== != > >= < <=
邏輯運算符(6)：&& || ! ^ & |
位運算符(7)：& | ~ ^ >> << >>>
java基本數據類型：
數值類型：
整型：byte、short、int、long
非整型：double、float
非數值類型：char[字符]、boolean[布爾]
一：算數運算符：
注：算數運算符操作數必須是數值類型。
分為一元運算符和二元運算符；
一元運算符，只有一個操作數；
二元運算符有兩個操作數，運算符在兩個操作數之間。
一元運算符：正‘+'，負‘-'，自加‘++'，自減‘--‘這四個。
①”++“和”--“運算符，只允許用于數值類型的變量，不允許用于表達式中；
"++"和”--“可以用于數值變量之前或者之后；
兩處使用差別：
”++“和”--“用于數值變量之前，在賦值操作中，先對被”++“或”--“操作變量值先加1或者先減1，然后在進行其他的操作；
"++"和”--“用于數值變量之后，在賦值操作中，先用被”++“或”--“的操作變量值進行其他的操作，然后在對其值加1或者減1。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package com.numerical; public class operator { public static void main(string[] args) { int a = 5; int b,c,d,f,g,h; b = +a; //正值 system.out.println("b="+b+",a="+a); c = -a; //負值 system.out.println("c="+c+",a="+a); int l = 2; d = ++l; //先l=l+1;再d=l system.out.println("d="+d+",l="+l); int m = 3; f = m++;//先f=m;再m=m+1 system.out.println("f="+f+",m="+m); int n = 4; g = --n;//先n=n-1;再g=n system.out.println("g="+g+",n="+n); int o = 6; h = o--;//先h=o;再o=o-1 system.out.println("h="+h+",o="+o); } } |
上代碼，輸出結果為：
b=5,a=5
c=-5,a=5
d=3,l=3
f=3,m=4
g=3,n=3
h=6,o=5
注：一元運算符和前后的操作數之間有空格，可能在有些編譯器下編譯時會出錯。
②二元運算符，加'+'，減'-'，乘'*'，除'/'，求余'%'。
在算數運算符中，”+“，”-“，”*“，”/“完成加減乘除四則運算，%是求兩個操作數相除后的余數。
運算規則和數學運算基本相同，在算數運算中，計算時按照從左向右的順序計算，乘除和求余優先于加減，不同的是，程序中的乘運算符不可省略，在數學中可寫為”y=2x“而程序中必須寫為”y=2*x“。
當二元運算的兩個操作數的數據類型不同時，運算結果的數據類型和參與運算的操作數的數據類型中精度較高(或位數較長)一致。
|
1
2
3
4
5
6
7
|
int a = 3; double b = 3.53;//或者3.53d float c = 1.7f; int d = 1; system.out.println("int /int :a/d="+a/d); system.out.println("double/int:b/a="+b/a); system.out.println("float/int:c/a="+c/a); |
輸出結果為：
int /int :a/d=3
double/int:b/a=1.1766666666666665
float/int:c/a=0.56666666
轉換原則：
從低精度向高精度轉換byte 、short、int、long、float、double
低精度到高精度會自動轉換，而高精度到低精度則要類型強制轉換。
|
1
2
3
4
|
int a = 7; double b = 5.33; b = a; a = (int) b; |
計算機的數據長度:
位：一個二進制數據0或1，是1bit(位)；
字節：存儲空間的計量單位,是1byte = 8bit；如數據庫的varchar為字節；
1. boolean 類型變量的取值有：ture、false,1字節（8位）
2. char數據類型有：unicode字符,16位
3. byte：一個字節（8位）（-128~127）（-2的7次方到2的7次方-1）
4. short：兩個字節（16位）（-32768~32767）（-2的15次方到2的15次方-1）
5. int：四個字節（32位）（一個字長）（-2147483648~2147483647）（-2的31次方到2的31次方-1）
6. long：八個字節（64位）（-9223372036854774808~9223372036854774807）（-2的63次方到2的63次方-1）
7. float：四個字節（32位）（3.402823e+38 ~ 1.401298e-45）（e+38是乘以10的38次方，e-45是乘以10的負45次方）
8. double：八個字節（64位）（1.797693e+308~ 4.9000000e-324）
對應java的基本數據類類型：integer、float、boolean、character、double、short、byte、long
注意：
①數值計算中語法現象——“晉升”，即：byte、short和char(低于int的數據類型)進行算術運算后，結果會自動提升成int類型；
②兩個char型運算時，自動轉換為int型；當char與別的類型運算時，也會先自動轉換為int型的，再做其它類型的自動轉換；
③算數運算可以加入小括號"()"提高優先級，優先小括號內運算，再其他運算符運算；
④算數運算前操作數變量必須賦值，反之，報語法錯誤。
二：關系運算符：
關系運算符用于比較兩個數值之間的大小，其運算結果為一個邏輯類型(boolean布爾類型)的數值。
等于'=='，不等于'!='，大于'>'，大于等于'>='，小于'<'，小于等于'<='
以下代碼為：
|
1
2
3
4
5
|
system.out.println("9.5<8 :"+(9.5<8)); system.out.println("8.5<=8.5:"+(8.5<=8.5)); system.out.println("a~z："+((int)'a')+"~"+((int)'z')); system.out.println("a~z："+((int)'a')+"~"+((int)'z')); system.out.println("'a' < 'a':"+('a' < 'a'));//字符'a'的unicode編碼值小于字符'a' |
輸出結果為:
9.5<8 :false
8.5<=8.5:true
a~z：97~122
a~z：65~90
'a' < 'a':true
注： boolean類型只能比較相等和不相等，不能比較大小；
>=的意思是大于或等于，兩者成立一個即可,結果為true，<=亦如此；
判斷相等的符號是兩個等號，而不是一個等號，這個需要特別小心。
實際代碼中，數值、變量以及運算結果都可以直接參與比較，只是程序中為了增強可讀性，有些時候需要將比較分開進行書寫。
比較運算符是程序設計中實現數據比較的基礎，也是很多邏輯實現的基礎，在程序邏輯中，經常通過比較一定的條件，來判斷后續的程序該如何執行。
三：邏輯運算符：
邏輯運算符要求操作數的數據類型為邏輯型，其運算結果也是邏輯型值。
邏輯運算的數據和邏輯運算符的運算結果是boolean類型。
邏輯與'&&'，邏輯或'||'，邏輯非'!'，邏輯異或'^'，邏輯與'&'，邏輯或'|'
邏輯運算符的真值表：
a和b是邏輯運算的兩個邏輯變量；
兩種邏輯與（&&和&）的運算規則基本相同，兩種邏輯或（||和|）的運算規則也基本相同。
&和|運算是把邏輯表達式全部計算完，而&&和||運算具有短路計算功能。
對于&來說，如果左側條件為false，也會計算右側條件的值，而對于&&來說，如果左側的條件為false，則不計算右側的條件，這種現象被稱作短路現象。
所謂短路計算，是指系統從左至右進行邏輯表達式的計算，一旦出現計算結果已經確定的情況，則計算過程即被終止。
對于&&運算來說，只要運算符左端的值為false，則因無論運算符右端的值為true或為false，其最終結果都為false。
所以，系統一旦判斷出&&運算符左端的值為false，則系統將終止其后的計算過程；
對于 || 運算來說，只要運算符左端的值為true，則因無論運算符右端的值為true或為false，其最終結果都為true。
所以，系統一旦判斷出|| 運算符左端的值為true，則系統將終止其后的計算過程。
注：異或相同為false，相反則為true。
利用短路現象：
在程序設計時使用&&和||運算符，不建議使用&和|運算符。
四、位運算符：
位運算是以二進制位為單位進行的運算，其操作數和運算結果都是整型值。
位與'&'，位或'|'，位非'~'，位異或'^'，右移'>>'，左移'<<'，0填充的右移'>>>'
位運算的位與'&'，位或'|'，位非'~'，位異或'^'與邏輯運算的相應操作的真值表完全相同，其差別只是位運算操作的操作數和運算結果都是二進制整數，而邏輯運算相應操作的操作數和運算結果都是邏輯值boolean型。
下邊為位&運算：
int a = 15; //x等于二進制數的00001111
int b = 6; //y等于二進制數的00000110
int c = x&y //z等于二進制數的00000110
結果為：二進制數的00000110
右移是將一個二進制數按指定移動的位數向右移位，移掉的被丟棄，左邊移進的部分或者補0（當該數為正時），或者補1（當該數為負時）。這是因為整數在機器內部采用補碼表示法，正數的符號位為0，負數的符號位為1。
將一個數左移"<<"會使該值乘以2的冪。
將一個數右移>>"會使該值除以2的冪。
右移（補零）運算符，即無符號右移，">>>"永遠不會產生負號，因為其符號位總是被補零。 不論被移動數是正數還是負數，左邊移進的部分一律補0。
|
1
2
|
system.out.println(1<<3); system.out.println(8>>3); |
輸出為：8
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。
右移和左移操作，是整數機器數的補碼表示法。
&運算符規定必須信號a和b都被充電，其結果才是充電。(1表示充電，0表示未充電)
|運算符規定只要信號a或b被充電，輸出結果就是充電。
^異或（xor）運算符規定如果信號a或b之一被充電，但是信號a和b不是同時被充電，則結果為充電。
~運算符也稱為按位求補，它翻轉所有的充電狀態值。
五、賦值運算符與其他運算符的簡捷使用方式 ：
① 賦值運算符可以與二元算術運算符、邏輯運算符和位運算符組合成簡捷運算符，從而可以簡化一些常用表達式的書寫。
在程序開發中，大量使用“一元運算符或移位運算符等”該區別簡化代碼的書寫，這樣做，因為這樣將增加閱讀代碼的難度，盡量注釋。
② 方括號[]和圓括號（）運算符
方括號[]是數組運算符，方括號[]中的數值是數組的下標，整個表達式就代表數組中該下標所在位置的元素值。
圓括號（）運算符用于改變表達式中運算符的優先級。
|
1
2
|
string [] sa = {"a","b","c","d"}; system.out.println(sa[2]); |
輸出為：c
③ 字符串加（+）運算符
當操作數是字符串時，加（+）運算符用來合并兩個字符串；當加（+）運算符的一邊是字符串，另一邊是數值時，機器將自動將數值轉換為字符串，并連接為一個字符串。
|
1
2
3
4
|
string a ="aa"; int c = 555; string b = a+"bbb"+c; system.out.println(b); |
輸出為：aabbb555
④ 條件運算符(三目運算符)
<表達式1> ？<表達式2> : <表達式3>
先計算<表達式1>的值，
當<表達式1>的值為true時，則將<表達式2>的值作為整個表達式的值；
當<表達式1>的值為false時，則將<表達式3>的值作為整個表達式的值。
|
1
2
3
|
int a = 55,b = 132,res; res = a > b ? a : b; system.out.println(res); |
輸出為：132
⑤強制類型轉換符
強制類型轉換符能將一個表達式的類型強制轉換為某一指定數據類型
|
1
2
3
4
|
int a; double b = 5.66600; a = (int) b; system.out.println(a); |
輸出為：5
⑥對象運算符instanceof
對象運算符instanceof用來測試一個指定對象是否是指定類（或它的子類）的實例，若是則返回true，否則返回false。
|
1
2
3
4
|
string s = new string("sa"); if(s instanceof object){ system.out.println("string is object class"); } |
輸出為：string is object class
⑦點運算符
點運算符"."的功能有兩個：一是引用類中成員，二是指示包的層次等級。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
string s = "i am string"; s = s.substring(5); system.out.println(s); map<integer, string> map = new hashmap<integer, string>(); map.put(1, "a"); map.put(2, "b"); map.put(3, "c"); iterator it = map.entryset().iterator(); while(it.hasnext()){ map.entry<integer, string> me =(map.entry<integer, string>) it.next(); system.out.println("key="+me.getkey()+",value="+me.getvalue()); } |
輸出為：
string
key=1,value=a
key=2,value=b
key=3,value=c
在實際的開發中，可能在一個運算符中出現多個運算符，計算時，就按照優先級級別的高低進行計算，級別高的運算符先運算，級別低的運算符后計算.
運算符優先級表
優先級自上而下，級別由高到低。
本文轉自互聯網，由動力節點整理發布
