Java學習筆記--運算子

Java的運算子，分為四類：
算數運算子、關係運算子、邏輯運算子、位運算子。
算數運算子(9)：+ - * / % ++ --
關係運算子(6)：== != > >= 邏輯運算子(6)：&& || ! ^ & |
位運算子(7)：& | ~ ^ >> >>

Java基本資料型別：
數值型別：
整型：byte、short、int、long
非整型：double、float

非數值型別：
char[字元]、boolean[布林]

一：算數運算子：
注：算數運算子運算元必須是數值型別。
分為一元運算子和二元運算子；
一元運算子，只有一個運算元；
二元運算子有兩個運算元，運算子在兩個運算元之間。
一元運算子：正‘+’，負‘-’，自加‘++’，自減‘--‘這四個。
①”++“和”--“運算子，只允許用於數值型別的變數，不允許用於表示式中；
"++"和”--“可以用於數值變數之前或者之後；
兩處使用差別：
”++“和”--“用於數值變數之前，在賦值操作中，先對被”++“或”--“操作變數值先加1或者先減1，然後在進行其他的操作；
"++"和”--“用於數值變數之後，在賦值操作中，先用被”++“或”--“的操作變數值進行其他的操作，然後在對其值加1或者減1。

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“。
當二元運算的兩個運算元的資料型別不同時，運算結果的資料型別和參與運算的運算元的資料型別中精度較高(或位數較長)一致。

        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
低精度到高精度會自動轉換，而高精度到低精度則要型別強制轉換。

        int a = 7;
        double b = 5.33;
        b = a;
        a = (int) b;
        System.out.println(a);

輸出：7

計算機的資料長度:
位：一個二進位制資料0或1，是1bit(位)；
位元組：儲存空間的計量單位,是1byte = 8bit；如資料庫的VARCHAR為位元組；
boolean 型別變數的取值有：ture、false,1位元組（8位）
char資料型別有：unicode字元,16位
byte：一個位元組（8位）（-128~127）（-2的7次方到2的7次方-1）
short：兩個位元組（16位）（-32768~32767）（-2的15次方到2的15次方-1）
int：四個位元組（32位）（一個字長）（-2147483648~2147483647）（-2的31次方到2的31次方-1）
long：八個位元組（64位）（-9223372036854774808~9223372036854774807）（-2的63次方到2的63次方-1）
float：四個位元組（32位）（3.402823e+38 ~ 1.401298e-45）（e+38是乘以10的38次方，e-45是乘以10的負45次方）
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布林型別)的數值。
等於'=='，不等於'!='，大於'>'，大於等於'>='，小於'

//以下程式碼為：
        System.out.println("9.5

輸出結果為:
9.5

8.5

a~z：97~122

A~Z：65~90

'A'

注： boolean型別只能比較相等和不相等，不能比較大小；

">="的意思是大於或等於，兩者成立一個即可,結果為true， 判斷相等的符號是兩個等號，而不是一個等號，這個需要特別小心。
實際程式碼中，數值、變數以及運算結果都可以直接參與比較，只是程式中為了增強可讀性，有些時候需要將比較分開進行書寫。
比較運算子是程式設計中實現資料比較的基礎，也是很多邏輯實現的基礎，在程式邏輯中，經常透過比較一定的條件，來判斷後續的程式該如何執行。

三：邏輯運算子：
邏輯運算子要求運算元的資料型別為邏輯型，其運算結果也是邏輯型值。
邏輯運算的資料和邏輯運算子的運算結果是boolean型別。
邏輯與'&&'，邏輯或'||'，邏輯非'!'，邏輯異或'^'，邏輯與'&'，邏輯或'|'
邏輯運算子的真值表：

A和B是邏輯運算的兩個邏輯變數；
兩種邏輯與（&&和&）的運算規則基本相同，兩種邏輯或（||和|）的運算規則也基本相同。
&和|運算是把邏輯表示式全部計算完，而&&和||運算具有短路計算功能。
對於&來說，如果左側條件為false，也會計算右側條件的值，而對於&&來說，如果左側的條件為false，則不計算右側的條件，這種現象被稱作短路現象。
所謂短路計算，是指系統從左至右進行邏輯表示式的計算，一旦出現計算結果已經確定的情況，則計算過程即被終止。
對於&&運算來說，只要運算子左端的值為false，則因無論運算子右端的值為true或為false，其最終結果都為false。
所以，系統一旦判斷出&&運算子左端的值為false，則系統將終止其後的計算過程；
對於 || 運算來說，只要運算子左端的值為true，則因無論運算子右端的值為true或為false，其最終結果都為true。
所以，系統一旦判斷出|| 運算子左端的值為true，則系統將終止其後的計算過程。
注：異或相同為false，相反則為true。
利用短路現象：
在程式設計時使用&&和||運算子，不建議使用&和|運算子。

四：位運算子：
位運算是以二進位制位為單位進行的運算，其運算元和運算結果都是整型值。
位與'&'，位或'|'，位非'~'，位異或'^'，右移'>>'，左移'>>'
位運算的位與'&'，位或'|'，位非'~'，位異或'^'與邏輯運算的相應操作的真值表完全相同，其差別只是位運算操作的運算元和運算結果都是二進位制整數，而邏輯運算相應操作的運算元和運算結果都是邏輯值boolean型。

下邊為位&運算：
int a = 15; //x等於二進位制數的00001111
int b = 6; //y等於二進位制數的00000110
int c = x&y //z等於二進位制數的00000110
結果為：二進位制數的00000110
右移是將一個二進位制數按指定移動的位數向右移位，移掉的被丟棄，左邊移進的部分或者補0（當該數為正時），或者補1（當該數為負時）。這是因為整數在機器內部採用補碼錶示法，正數的符號位為0，負數的符號位為1。
將一個數左移" 　　 將一個數右移>>"會使該值除以2的冪。
　　 右移（補零）運算子，即無符號右移，">>>"永遠不會產生負號，因為其符號位總是被補零。 不論被移動數是正數還是負數，左邊移進的部分一律補0。

            System.out.println(1>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不是同時被充電，則結果為充電。
~運算子也稱為按位求補，它翻轉所有的充電狀態值。

五：賦值運算子與其他運算子的簡捷使用方式 ：

① 賦值運算子可以與二元算術運算子、邏輯運算子和位運算子組合成簡捷運算子，從而可以簡化一些常用表示式的書寫。

在程式開發中，大量使用“一元運算子或移位運算子等”該區別簡化程式碼的書寫，這樣做，因為這樣將增加閱讀程式碼的難度，儘量註釋。
② 方括號[]和圓括號（）運算子
方括號[]是陣列運算子，方括號[]中的數值是陣列的下標，整個表示式就代表陣列中該下標所在位置的元素值。
圓括號（）運算子用於改變表示式中運算子的優先順序。
String [] sa = {"a","b","c","d"};
System.out.println(sa[2]);

輸出為：c
③ 字串加（+）運算子
當運算元是字串時，加（+）運算子用來合併兩個字串；當加（+）運算子的一邊是字串，另一邊是數值時，機器將自動將數值轉換為字串，並連線為一個字串。

        String a ="aa";
        int c = 555;
        String b = a+"bbb"+c;
        System.out.println(b);

輸出為：aabbb555
④ 條件運算子(三目運算子)
？ :
先計算的值，
當的值為true時，則將的值作為整個表示式的值；
當的值為false時，則將的值作為整個表示式的值。

        int a = 55,b = 132,res;
        res = a > b ? a : b;
        System.out.println(res);

輸出為：132
⑤強制型別轉換符
強制型別轉換符能將一個表示式的型別強制轉換為某一指定資料型別

        int a;
        double b = 5.66600;
        a = (int) b;
        System.out.println(a);

輸出為：5
⑥物件運算子instanceof
物件運算子instanceof用來測試一個指定物件是否是指定類（或它的子類）的例項，若是則返回true，否則返回false。

        String s = new String("sa");
        if(s instanceof Object){
            System.out.println("String is object class");
        }

輸出為：String is object class
⑦點運算子
點運算子"."的功能有兩個：一是引用類中成員，二是指示包的層次等級。

        String s = "i am string";
        s = s.substring(5);
        System.out.println(s);
        Map map = new HashMap();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        Iterator it = map.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry me =(Map.Entry) it.next();
            System.out.println("key="+me.getKey()+",value="+me.getValue());
        }

輸出為：
string
key=1,value=A
key=2,value=B
key=3,value=C
在實際的開發中，可能在一個運算子中出現多個運算子，計算時，就按照優先順序級別的高低進行計算，級別高的運算子先運算，級別低的運算子後計算.
運算子優先順序表

優先順序自上而下，級別由高到低。