六、运算符

主要内容：

• 理解运算符++ --的运算方式
• 理解+符号在字符串中的作用
• 理解比较运算符
• 理解逻辑运算符
• 掌握三元运算符的格式和计算结果

1 算数运算符

算术运算符	说明
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字相除取余数
++ 、--	自增自减运算

Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。

public static void main(String[] args) {
	int i = 1234;
	System.out.println(i/1000*1000);//计算结果是1000
}

1.1 ++、-- 运算

1. ++ ：变量自己增长1。
2. -- ：变量自己减少1，用法与 ++ 一致。
3. 独立运算：变量在独立运算时，“前++（ ++i ）” 和 “后++（ i++ ）” 没有区别 。
4. 混合运算：和其他变量放在一起，“前++” 和 “后++” 就产生了不同。
   1. 变量前++：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2；

      public static void main(String[] args) {
      	int a = 1;
      	int b = ++a;
      	System.out.println(a);//计算结果是2
      	System.out.println(b);//计算结果是2
      }
      

   2. 变量后++：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。

      public static void main(String[] args) {
      	int a = 1;
      	int b = a++;
      	System.out.println(a);//计算结果是2
      	System.out.println(b);//计算结果是1
      }
      

1.2 + 符号在字符串中的操作

+ 符号在遇到字符串的时候，表示连接、拼接的含义。
"a"+"b" 的结果是 “ab” 。

public static void main(String[] args){
	System.out.println("5 + 5 = " + 5 + 5);//输出5 + 5 = 55
}

2 赋值运算符

赋值运算符：将符号右边的值，赋给左边的变量。

赋值运算符	说明
=	等于号
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等

public static void main(String[] args){
	int i = 5;
	i += 5;//计算方式 i=i+5 变量i先加5，再赋值变量i
	System.out.println(i); //输出结果是10
}

3 比较运算符

比较运算符：两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

比较运算符	说明
==	比较符号两边数据是否相等，相等结果是true。
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。
!=	不等于符号 ，如果符号两边的数据不相等，结果是true。

public static void main(String[] args) {
	System.out.println(1 == 1);//true
	System.out.println(1 < 2);//true
	System.out.println(3 > 4);//false
	System.out.println(3 <= 4);//true
	System.out.println(3 >= 4);//false
	System.out.println(3 != 4);//true
}

4 逻辑运算符

逻辑运算符：连接两个布尔值的运算符，运算结果都是布尔值 true 或者 false 。

逻辑运算符	名称	说明
&	与	1. 两边都是true，结果是true 2. 一边是false，结果是false 无短路特点：符号左边是false，右边仍运算。
|	或	1. 一边是true，结果是true 2. 两边都是false，结果是false 无短路特点：符号左边是true，右边仍运算。
&&	短路与	1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算。
||	短路或	1. 一边是true，结果是true 2. 两边都是false，结果是false 短路特点：符号左边是true，右边不再运算。
^	异或	1. 两边相同，结果是false 2. 两边不同，结果是true
!	非	1. ! true 结果是false 2. ! false 结果是true

public static void main(String[] args) {
	System.out.println(true && true);//true
	System.out.println(true && false);//false
	System.out.println(false && true);//false，右边不计算
	
	System.out.println(false || false);//false
	System.out.println(false || true);//true
	System.out.println(true || false);//true，右边不计算

	System.out.println(true ^ true);//false
	System.out.println(false ^ true);//true
	
	System.out.println(!false);//true
}

& 和 && ，|| 和 | 在运算结果上一样，只是 && 和 || 具有短路特点。

5 位运算符

位运算符：对单个或多个数据进行按位运算。

按位运算符	名称	形式	说明
&	按位与	A & B	将A和B的二进制形式的每一位上的数字依次进行 & 运算。 运算规则：逢0得0。 1 & 1 = 1； 1 & 0 = 0； 0 & 1 = 0； 0 & 0 = 0 3 & 4：   3的二进制：00000000 00000000 00000000 00000011   4的二进制：00000000 00000000 00000000 00000100   3 & 4：        00000000 00000000 00000000 00000000，结果是：0
|	按位或	A | B	将A和B的二进制形式的每一位上的数字依次进行 | 运算。 运算规则：逢1得1。 1 | 1 = 1； 1 | 0 = 1； 0 | 1 = 1； 0 | 0 = 0 3 | 4：   3的二进制：00000000 00000000 00000000 00000011   4的二进制：00000000 00000000 00000000 00000100   3 | 4：         00000000 00000000 00000000 00000111，结果是：7
^	按位异或	A ^ B	将A和B的二进制形式的每一位上的数字依次进行 ^ 运算。 运算规则：相同为0，不同为1（同0异1）。 1 ^ 1 = 0； 1 ^ 0 = 1； 0 ^ 1 = 1； 0 ^ 0 = 0 3 ^ 4：   3的二进制：00000000 00000000 00000000 00000011   4的二进制：00000000 00000000 00000000 00000100   3 ^ 4：         00000000 00000000 00000000 00000111，结果是：7
~	按位非	~ A	将A的二进制形式的补码的每一位上的数字依次进行 ~ 运算。 运算规则：取反（0，1互换）。 ~ 1 = 0； ~ 0 = 1 ~ 3：   3的二进制：00000000 00000000 00000000 00000011（原码）                       00000000 00000000 00000000 00000011（补码）   ~：              11111111   11111111   11111111   11111100（补码取反）   ~ 3：           10000000 00000000 00000000 00000100（原码），结果是：-4 ~ -4：   -4的二进制：10000000 00000000 00000000 00000100（原码）                         11111111  11111111   11111111   11111100（补码）   ~：                00000000 00000000 00000000 00000011（补码取反）   ~ -4：            00000000 00000000 00000000 00000011（原码），结果是：3 注意：正数的原码，反码，补码都是相同的。            1. 负数的反码：符号位1不变，其他位按原码取反；            2. 负数的补码：反码+1；            3. 负数的原码：符号位1不变，其他位按补码取反，再+1。
<<	按位左移	A << n	将数字A的二进制形式的每一位数字往左边移动n位，最左边的n位移出即丢弃，最右边空出来的n位则补0。 运算规则：A << n = A * 22 3 << 2：   3的二进制：00000000 00000000 00000000 00000011   3 << 2： 00 00000000 00000000 00000000 000011 00，结果是：12
>>	按位右移	A >> n	将数字A的二进制形式的每一位数字往右边移动n位，最右边的n位移出即丢弃，最左边空出来的n位则：若最高位为0补0；若最高位为1补码补1。 运算规则：A >> n = A / 22  (A > 0) 24 >> 2：   24的二进制：00000000 00000000 00000000 00011000   24 >> 2：       00000000 00000000 00000000 00000110 00，结果是：6 -24 >> 2：   -24的二进制: 10000000 00000000 00000000 00011000（原码）                         11111111  11111111   11111111   11100111（反码）                         11111111  11111111   11111111   11101000（补码）   -24 >> 2：      11111111  11111111   11111111   11111010 00（补码右移）                         10000000 00000000 00000000 00000110（原码），结果是：-6
>>>	按位无符号右移	A >>> n	将数字A的二进制形式的每一位数字往右边移动n位，最右边的n位移出即丢弃，最左边空出来的n位则无论最高位为0还是1，全部补0。 -24 >>> 2：   -24的二进制: 10000000 00000000 00000000 00011000（原码）                         11111111  11111111   11111111   11100111（反码）                         11111111  11111111   11111111   11101000（补码）   -24 >>> 2：    00111111  11111111  11111111   11111010 00（补码右移）                         00111111  11111111  11111111   11111010（正数原码=补码），结果是：1073741818

6 三元运算符

1. 格式：布尔类型表达式 ? 结果1 : 结果2; 。

2. 计算方式：

   1. 布尔类型表达式结果是true：返回结果1；
   2. 布尔类型表达式结果是false：返回结果2。

3. 案例：求a,b,c三个整数中的最大值：

   public static void main(String[] args) {
   	int a = 100;
   	int b = 200;
   	int c = 300;
   
   	System.out.println((a>b) ? ((a>c) ? a : c) : ((b>c) ? b : c));//300
   }