Java学习09-运算符

Java运算符

计算机的最基本用途之一基于是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成一下几组：

• 算术运算符
• 赋值运算符
• 比较运算符 (关系运算符)
• 逻辑运算符
• 位运算符
• 三元运算符

1. 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模(取余)	7%5	2
(前)++	(前)++ :先自增1，后运算	a=2; b=++a;	a=3;b=3
(后)++	(后)++ :先运算，后自增1	a=2; b=a++;	a=3;b=2
(前)--	(前)-- :先自减1，后运算	a=2; b=--a;	a=1;b=1
(后)--	(后)-- :先运算，后自减1	a=2; b=a--;	a=1;b=2
+	字符串连接	“He”+"llo"	"Hello"

示例代码

/*
运算符之一：算数运算符
+ - + * / % (前)++ (后)++ (前)-- (后)-- +

*/

class AriTest{
	public static void main(String[] args) {
		
		// 除号: /
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1); // 2

		int result2 = num1 / num2 * num2;
		System.out.println(result2); // 10

		double result3 = num1 / num2;
		System.out.println(result1); // 2.0

		double result4 = num1 / num2 + 0.0; // 2.0
		double result5 = num1 / (num2 + 0.0); // 2.4
		double result6 = (double)num1 / num2; // 2.4
		double result7 = (double)(num1 / num2); // 2.0
		System.out.println(result5);
		System.out.println(result6);

		// %:取余运算
		// 结果的符号与被模数的符号相同
		// 开发中，经常使用%来判断是否能被除尽的情况。
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);


		// (前)++ :先自增1，后运算
		// (后)++ :先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1);

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2);

		int a3 = 10;
		++a3; // a3++;
		int b3 = a3;

		
		// 注意点：
		short s1 = 10;
		//s1 = s1 + 1; // 编译失败
		//s1 = (short)(s1 + 1); // 正确的
		s1++; // 自增1不会改变本身变量的数据类型
		System.out.println(s1);

		// 问题：
		byte bb1 = 127;
		bb1++;
		System.out.println("bb1 = " + bb1);


		// (前)-- :先自减1，后运算
		// (后)-- :先运算，后自减1

		int a4 = 10;
		int b4 = --a4;
		System.out.println("a4 = " + a4 + ",b4 = " + b4);

		int a5 = 10;
		int b5 = a5--;
		System.out.println("a5 = " + a5 + ",b5 = " + b5);

	}
}

运行结果

2. 赋值运算符

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。

示例代码

/*
运算符之二：赋值运算符
=  +=  -=  *=  /=  %=


*/
class SetValueTest {
	public static void main(String[] args) {
		// 赋值符号：=
		int i1 = 10;
		int j1 = 10;

		int i2,j2;
		// 连续赋值
		i2 = j2 = 10;

		int i3 = 10, j3 = 20;

		//*************************
		int num1 = 10;
		num1 += 2; // num1 = num1 + 2;
		System.out.println(num1); // 12

		int num2 = 12;
		num2 %= 5;// num2 = num2 % 5;
		System.out.println(num2); // 2

		short s1 = 10;
		//s1 = s1 + 2;//编译失败
		s1 += 2; // 结论：不会改变变量本身的数据类型
		System.out.println(s1);

		// 开发中，如果希望实现+2的操作，有几种方法？(前提：int num = 10;)
		// 方式一：num = num + 2;
		// 方式二：num += 2; (推荐)

		// 开发中，如果希望实现+1的操作，有几种方法？(前提：int num = 10;)
		// 方式一：num = num + 1;
		// 方式二：num += 1;
		// 方式三：num++; (推荐)

	
		// 练习1
		int i = 1;
		i *= 0.1;
		System.out.println(i); // 0
		i++;
		System.out.println(i); // 1

		// 练习2
		int m = 2;
		int n = 3;
		n *= m++;	// n = n * m++;
		System.out.println("m=" + m);	// 3
		System.out.println("n=" + n);	// 6

		// 练习3
		int n1 = 10;
		n1 += (n1++) + (++n1); // n1 = n1 + (n1++) + (++n1)
		System.out.println(n1); // 32
		

	}
}

运行结果

3. 比较运算符

比较运算符是指可以使用下列运算符比较两个值。当用运算符比较两个值时，结果是一个逻辑值，不是 true (成立)  就是false (不成立)  的运算符号。

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4==3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true
instanceof	检查是否是类的对象	"Hello" instanceof String	true

• 比较运算符的结果是boolean类型，也就是要么是true，要么是false
• 比较运算符 "==" 不能误写成 "="

示例代码

/*
运算符之三：比较运算符
==  !=  >  <  >=  <=  instanceof 

结论：
1. 比较运算符的结果是boolean类型
2. 区分  ==  和  =
*/

class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;

		System.out.println(i == j); // false
		System.out.println(i = j);	// 20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1); // false
		System.out.println(b2 = b1);  // true


	}
}

运行结果

4. 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

常用逻辑运算符：

&——逻辑与 |——逻辑或 !——逻辑非 &&——短路与 ||——短路或 ^——逻辑异或

a	b	a&b	a&&b	a|b	a||b	!a	a^b
true	true	true	true	true	true	false	false
true	false	false	false	true	true	false	true
false	true	false	false	true	true	true	true
false	false	false	false	false	false	true	false

示例代码

/*
运算符之四：逻辑运算符

& && | || ! ^

说明：逻辑运算符操作的都是boolean类型的变量

*/

class LogicTest {
	public static void main(String[] args) {
		
		// 区分 & 与 &&
		// 相同点1：& 与 && 的运算结果相同
		// 相同点2：当符号左边是true时，二者都会执行符号右边的运算
		// 不同点：当符号左边时false时，&继续执行符号右边的运算，而&&不再执行符号右边的运算。
		// 开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num1 = " + num1);

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b1 && (num2++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2);


		// 区分 | 与 ||
		// 相同点1：| 与 || 的运算结果相同
		// 相同点2：当符号左边是false时，二者都会执行符号右边的运算
		// 不同点：当符号左边时true时，|继续执行符号右边的运算，而||不再执行符号右边的运算。
		// 开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 & (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num3 = " + num3);

		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b1 && (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num4 = " + num4);
	}
}

运行结果

5. 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

位运算符

运算符	运算	范例
<<	左移	3 << 2 = 12 → 3 * 2 * 2 = 12
>>	右移	3 >> 1 = 1 → 3 / 2 = 1
>>>	无符号右移	3 >>> 1 = 1 → 3 / 2 = 1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 5
^	异或运算	6 ^ 3 = 5
~	取反运算	~6 = -7

• 位运算是直接对整数的二进制进行的运算

位运算符的细节

<<	空位补0，被移除的高位丢弃，空缺位补0。
>>	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1；
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	二进制位进行 & 运算，只有1 & 1时结果是1，否则是0；
|	二进制位进行 | 运算，只有0 | 0时结果是0，否则是1；
^	相同二进制位进行 ^ 运算，结果是0； 1^1 = 0, 0 ^ 0 = 0; 不相同二进制位 ^ 运算结果是1。1^0=1, 0^1 = 1
~	正数取反，各二进制码按补码各位取反；负数取反，各二进制码按补码各位取反

示例代码

/*
运算符之五：位运算符    (了解)

结论：
1. 位运算符操作的都是整型的数据
2. << : 在一定范围内，每向左移1位，相当于 * 2
   >> : 在一定范围内，每向右移1位，相当于 / 2

最高效方式计算 2 * 8 ？ 2 << 3 或 8 << 1

*/

class BitTest {
	public static void main(String[] args) {

		int i = 21;
		i = -21;
		
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i << 3 :" + (i << 3));
		System.out.println("i << 27 :" + (i << 27));

		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));
		System.out.println("m | n :" + (m | n));
		System.out.println("m ^ n :" + (m ^ n));

		// 练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		// 方式一：定义临时变量
		// 推荐的方式
		int temp = num1;
		num1 = num2;
		num2 = temp;

		// 方式二：好处：不用定义临时变量
		// 弊端： ① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
		// num1 = num1 + num2
		// num2 = num1 - num2;
		// num1 = num1 - num2;

		// 方式三：使用位运算符
		// 有局限性：只能适用于数值类型
		// num1 = num1 ^ num2
		// num2 = num1 ^ num2;
		// num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);

	}
}

运行结果

6. 三元运算符

Java 提供了一个特别的三元运算符（也叫三目运算符）经常用于取代某个类型的 if-then-else 语句。三元运算符的格式为：(条件表达式) ? 表达式1 : 表达式2;

其含义为：根据条件表达式真或假，决定执行表达式1，还是表达式2。如果条件表达式为true，则执行表达式1；如果条件表达式为false，则执行表达式2。

示例代码

/*
运算符之六：三元运算符
1. 结构：(条件表达式) ? 表达式1 : 表达式2;

2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2。
  如果条件表达式为true，则执行表达式1。
  如果条件表达式为false，则执行表达式2。
③ 表达式1 和表达式2 要求是一致的。
③ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么有限选择三元运算符。原因：简洁、执行效率高。

*/
class SanYuanTest {
	public static void main(String[] args) {
		
		// 获取两个整数的较大值
		int m = 12;
		int n = 5;

		int max = (m > n) ? m : n;
		System.out.println(max);

		double num = (m > n) ? 2 : 1.0;
		System.out.println(num);

		// (m > n) ? 2 : "n大"; // 编译错误，无法统一表达式1和表达式2的数据类型

		// *****************************
		n = 12;
		String maxStr = (m > n) ? "m大" : (m == n) ? "m和n相等" : "n大";
		System.out.println(maxStr);
	
		// *****************************
		// 获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2) ? n1 : n2;
		int max2 = (max1 > n3) ? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);

		// 不建议
		// int max3 = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;
		// System.out.println("三个数中的最大值为：" + max3);

		// 改写成if-else：
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

运行结果

7. 运算符的优先级

Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、--	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=	从右向左

• 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。