java基礎：運算符的基本用法
運算符：
就是對常量和變量進行操作的符號。
算數運算符：
A:+,-,*,/,%,++,--
B:+的用法
a:加法
b:正號
c:字符串連接符
C:/和%的區別
數據做除法操作的時候，/取得是商，%取得是余數
D:++和--的用法
a:他們的作用是自增或者自減
b:使用
**單獨使用
放在操作數據的前面和後面效果一樣。
a++或者++a效果一樣。
**參與操作使用
放在操作數的前面：先自增或者自減，再參與操作
int a = 10;
int b = ++a;
放在操作數的後面：先參與操作，再自增或者自減
int a = 10;
int b = a++;
public static void main(String[] args) {
//定義變量
int x = 3; //把3賦值給int類型的變量x
int y = 4;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y); //整數相除只能得到整數
//我就想得到小數，該腫麽辦呢?
//只需要把操作的數據中任意的一個數據變為浮點數
System.out.println(x*1.0/y);
//%的應用
System.out.println(x%y); //得到的是余數
}
註意事項：
A:整數相除只能得到整數。如果想得到小數，必須把數據變化為浮點數類型
B:/獲取的是除法操作的商，%獲取的是除法操作的余數
++；--的使用：就是對變量進行自增或者自減1
單獨使用：
放在操作數的前面和後面效果一樣。(這種用法是我們比較常見的)
參與運算使用：
放在操作數的前面，先自增或者自減，然後再參與運算。
放在操作數的後面，先參與運算，再自增或者自減。
code： |
public static void main(String[] args) { //定義兩個變量 int x = 3; int y = 4;
//字符串的拼接 //System.out.println("x:"+x); //System.out.println("y:"+y);
System.out.println("x:"+x+",y:"+y);
//單獨使用 //x++; //y--; ++x; --y; //System.out.println(x); System.out.println("x:"+x+",y:"+y);
//意外的類型,常量是不可以這樣做的 //System.out.println(10++);
System.out.println("-------------------"); //參與運算使用 int a = 3; int b = 4;
//int c = a++; //int d = b--;
int c = ++a; int d = --b;
System.out.println("a:"+a); //4, 4 System.out.println("b:"+b); //3, 3 System.out.println("c:"+c); //3, 4 System.out.println("d:"+d); //4, 3 } |
demo： |
/* ++,--
第一題： int a = 10; int b = 10; int c = 10;
a = b++; c = --a; b = ++a; a = c--; 請分別計算出a,b,c的值
第二題： int x = 4; int y = (x++)+(++x)+(x*10); 請分別計算出x,y的值 */ class OperatorTest { public static void main(String[] args) { int a = 10; int b = 10; int c = 10;
a = b++; //a=10,b=11,c=10 c = --a; //a=9,b=11,c=9 b = ++a; //a=10,b=10,c=9 a = c--; //a=9,b=10,c=8
System.out.println("a:"+a); System.out.println("b:"+b); System.out.println("c:"+c); System.out.println("--------------");
int x = 4; int y = (x++)+(++x)+(x*10); //4+6+60 //x=5,6
System.out.println("x:"+x); System.out.println("y:"+y); } } |
+號的用法：
A:加法
B:正號
C:字符串連接符
code： |
public static void main(String[] args) { //加法 System.out.println(3+4);
//正號 System.out.println(+4);
System.out.println(‘a‘); System.out.println(‘a‘+1); //這裏是加法
//字符串連接符 System.out.println("hello"+‘a‘+1); System.out.println(‘a‘+1+"hello"); } |
賦值運算符：
基本的賦值運算符：=
把=右邊的數據賦值給左邊。
擴展的賦值運算符：+=,-=,*=,/=,%=
+= 把左邊和右邊做加法，然後賦值給左邊。
code： |
public static void main(String[] args) { //定義一個變量 int x = 10;
//其他用法 int a,b; a = b = 10; System.out.println(a); System.out.println(b); System.out.println("-----------");
//定義一個變量 int y = 10;
y += 20;
System.out.println(y);
} |
code |
/* short s=1;s = s+1;
short s=1;s+=1; 上面兩個代碼有沒有問題，如果有，那裏有問題。
為什麽第二個木有問題呢? 擴展的賦值運算符其實隱含了一個強制類型轉換。
s += 1; 不是等價於 s = s + 1; 而是等價於 s = (s的數據類型)(s + 1); */ class OperatorTest { public static void main(String[] args) { //short s = 1; //s = s + 1; //System.out.println(s);
short s = 1; s += 1; //好像是 s = s + 1; System.out.println(s); } } |
比較運算符：
比較運算符：
==,!=,>,>=,<,<=
特點：
無論你的操作是簡單還是復雜，結果是boolean類型。
註意事項：
"=="不能寫成"="。
code |
public static void main(String[] args) { int x = 3; int y = 4; int z = 3;
System.out.println(x == y); System.out.println(x == z); System.out.println((x+y) == (x+z)); System.out.println("------------");
System.out.println(x != y); System.out.println(x > y); System.out.println(x >= y); System.out.println(x < y); System.out.println(x <= y); System.out.println("------------");
int a = 10; int b = 20;
//boolean flag = (a == b); //boolean flag = (a = b); //這個是有問題的，不兼容的類型 //System.out.println(flag);
int c = (a = b); //把b賦值給a，然後把a留下來 System.out.println(c); } |
邏輯運算符：
邏輯運算符：
&,|,^,!
&&,||
特點：
邏輯運算符一般用於連接boolean類型的表達式或者值。
表達式：就是用運算符把常量或者變量連接起來的符合java語法的式子。
算術表達式：a + b
比較表達式：a == b
結論：
&邏輯與:有false則false。
|邏輯或:有true則true。
^邏輯異或:相同為false，不同為true。
舉例：情侶關系。男男,男女,女男,女女
!邏輯非:非false則true，非true則false。
特點：偶數個不改變本身。
code |
public static void main(String[] args) { int a = 3; int b = 4; int c = 5;
//&邏輯與 System.out.println((a > b) & (a > c)); //false & false = false System.out.println((a > b) & (a < c)); //false & true = false System.out.println((a < b) & (a > c)); //true & false = false System.out.println((a < b) & (a < c)); //true & true = true System.out.println("---------------");
//|邏輯或 System.out.println((a > b) | (a > c)); //false | false = false System.out.println((a > b) | (a < c)); //false | true = true System.out.println((a < b) | (a > c)); //true | false = true System.out.println((a < b) | (a < c)); //true | true = true System.out.println("---------------");
//^邏輯異或 System.out.println((a > b) ^ (a > c)); //false ^ false = false System.out.println((a > b) ^ (a < c)); //false ^ true = true System.out.println((a < b) ^ (a > c)); //true ^ false = true System.out.println((a < b) ^ (a < c)); //true ^ true = false System.out.println("---------------");
//!邏輯非 System.out.println(!(a > b)); //!false = true System.out.println(!(a < b)); //!true = false System.out.println(!!(a > b)); //!!false = false System.out.println(!!!(a > b)); //!!false = true |
code： &&和&的區別? 同理||和|的區別? A:最終結果一樣。 B:&&具有短路效果。左邊是false，右邊不執行。
開發中常用的邏輯運算符： &&,||,! |
public static void main(String[] args) { int a = 3; int b = 4; int c = 5;
//&&雙與 System.out.println((a > b) && (a > c)); //false && false = false System.out.println((a > b) && (a < c)); //false && true = false System.out.println((a < b) && (a > c)); //true && false = false System.out.println((a < b) && (a < c)); //true && true = true System.out.println("----------------");
int x = 3; int y = 4;
//boolean b1 = ((x++ == 3) & (y++ == 4)); //boolean b1 = ((x++ == 3) && (y++ == 4)); //boolean b1 = ((++x == 3) & (y++ == 4)); boolean b1 = ((++x == 3) && (y++ == 4)); System.out.println("x:"+x); System.out.println("y:"+y); System.out.println(b1); } |
位運算符：
&,|,^,~
<<,>>,>>>
要做位運算，首先要把數據轉換為二進制
code： |
public static void main(String[] args) { //&,|,^,~
int a = 3; int b = 4;
System.out.println(3 & 4); System.out.println(3 | 4); System.out.println(3 ^ 4); System.out.println(~3); } |
分析：因為是位運算，所以我們必須先把數據換算成二進制。
3的二進制：11 00000000 00000000 00000000 00000011 4的二進制：100 00000000 00000000 00000000 00000100
&位與運算：有0則0。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000000 結果是：0
|位或運算：有1則1。 00000000 00000000 00000000 00000011 |00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 結果是：7
^位異或運算：相同則0，不同則1。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 結果是：7
~按位取反運算符：0變1，1變0 00000000 00000000 00000000 00000011 ~11111111 11111111 11111111 11111100 (補碼)
補碼：11111111 11111111 11111111 11111100 反碼：11111111 11111111 11111111 11111011 原碼：10000000 00000000 00000000 00000100 結果是：-4 |
^的特點：一個數據對另一個數據位異或兩次，該數本身不變。
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a ^ b ^ b); //10
System.out.println(a ^ b ^ a); //20
}
code：請自己實現兩個整數變量的交換 |
//方式1：使用第三方變量(開發中用的) /* int c = a; a = b; b = c; System.out.println("a:"+a+",b:"+b); System.out.println("------------"); */
//方式2：用位異或實現(面試用) //左邊：a,b,a //右邊：a ^ b /* a = a ^ b; b = a ^ b; //a ^ b ^ b = a a = a ^ b; //a ^ b ^ a = b System.out.println("a:"+a+",b:"+b); */
//方式3：用變量相加的做法 /* a = a + b; //a=30 b = a - b; //b=10 a = a - b; //a=20 System.out.println("a:"+a+",b:"+b); */
//方式4：一句話搞定 b = (a+b) - (a=b); //b=30-20=10,a=20 System.out.println("a:"+a+",b:"+b); |
|
<<:左移 左邊最高位丟棄，右邊補齊0
>>:右移 最高位是0，左邊補齊0；最高為是1，左邊補齊1
>>>:無符號右移 無論最高位是0還是1，左邊補齊0
code： |
public static void main(String[] args) { //<< 把<<左邊的數據乘以2的移動次冪 System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
//>> 把>>左邊的數據除以2的移動次冪 System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6 System.out.println(24 >>> 2);
System.out.println(-24 >> 2); System.out.println(-24 >>> 2); } } /* 計算出3的二進制：11 00000000 00000000 00000000 00000011 (00)000000 00000000 00000000 0000001100
>>的移動： 計算出24的二進制：11000 原碼：10000000 00000000 00000000 00011000 反碼：11111111 11111111 11111111 11100111 補碼：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000 1111111111 11111111 11111111 111010(00) 補碼
補碼：1111111111 11111111 11111111 111010 反碼：1111111111 11111111 11111111 111001 原碼：1000000000 00000000 00000000 000110
結果：-6
>>>的移動： 計算出24的二進制：11000 原碼：10000000 00000000 00000000 00011000 反碼：11111111 11111111 11111111 11100111 補碼：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000 0011111111 11111111 11111111 111010(00)
結果： */ |
三元（目）運算符：
格式：
比較表達式?表達式1:表達式2;
比較表達式:結果是一個boolean類型。
執行流程：
根據比較表達式的計算返回一個true或者false。
如果是true，就把表達式1作為結果。
如果是false，就把表達式2作為結果。
code： |
public static void main(String[] args) { int x = 100; int y = 200;
int z = ((x > y)? x: y);
//int z = ((x < y)? x: y);
//int z = ((x == y)? x: y);
//報錯 //int z = ((x = y)? x : y);
System.out.println("z:"+z); } |
code： 獲取兩個整數中的最大值 獲取三個整數中的最大值 比較兩個整數是否相同
|
public static void main(String[] args) { //獲取兩個整數中的最大值 int x = 100; int y = 200;
int max = (x > y? x: y); System.out.println("max:"+max); System.out.println("--------");
//獲取三個整數中的最大值 int a = 10; int b = 30; int c = 20;
//分兩步： //A:先比較a,b的最大值 //B:拿a,b的最大值在和c進行比較 int temp = ((a > b)? a: b); //System.out.println(temp); int max1 = (temp > c? temp: c); System.out.println("max1:"+max1);
//一步搞定 //int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c); //這種做法不推薦。 //int max2 = a > b?a > c? a: c:b > c? b: c; //System.out.println("max2:"+max2); System.out.println("--------");
//比較兩個整數是否相同 int m = 100; int n = 200;
//boolean flag = (m == n)? true: false; boolean flag = (m == n); System.out.println(flag); } |
java基礎：運算符的基本用法