day05_Java中的运算符

在Java中提供了丰富的运算符

• 其按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符
  
• 按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
  

我们又称用运算符连接起来的式子就是表达式。下面我们来具体学习一下每个运算符的作用吧。
算数运算符

​​代码示例

1. /*
2. 被除数 ÷ 除数 = 商 ......    余数
3. */
4. public class Demo01Operator {
5.     public static void main(String[] args) {
6.         int a = 10;
7.         int b = 4;
9.         // + - * 和我们小学的规则一样
10.         System.out.println(a + b); //14
11.         System.out.println(a - b);//6
12.         System.out.println(a * b);//40
14.         //2个整数相除，结果就是商，整数相除 不保留小数，如果想要显示小数 使用浮点类型计算
15.         System.out.println(a / b);//2
17.         //int * double / int ==> double /    int ==> double / double ==> double
18.         System.out.println((a * 1.0) / b);// 2.5
19.    /*
20.     %运算符: 取余数(模)运算符
21.     作用:
22.         1.判断数字的奇偶性:
23.             数字%2 结果是0 说明数字是偶数
24.             数字%2 结果不是0 说明数字是奇数
26.         2.判断一个数字是否能够被另外一个数字整除
27.             结果为0: 说明可以整除
28.             结果不为0: 说明不可以整除
29.     */
30.         //结果是0 说明10是偶数，结果是 1 说明11是奇数
31.         System.out.println(10 % 2);//0
32.         System.out.println(11 % 2);//1
33.         
34.         //结果是0 说明100可以被25整除，否则说明100不可以被26整除
35.         System.out.println(100 % 25);//0
36.         System.out.println(100 % 26);//22
37.     }
38. }

复制代码

注意事项:

• Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
  
• 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
  
• / 和%的区别：两个整数做除法，/取结果的商，%取结果的余数。取模的结果只和被除数的正负号相同。
  

案例：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

1. import java.util.Scanner;
3. public class Demo04Operator {
4.     public static void main(String[] args) {
5.         // 1：使用Scanner键盘录入一个三位数
6.         Scanner sc = new Scanner(System.in);
7.         System.out.println("请输入一个三位数");
8.         int num = sc.nextInt();
9.         // 2：个位的计算：数值 % 10
10.         int ge = num % 10;                        // 123 % 10 = 3
11.         // 3：十位的计算：数值 / 10 % 10
12.         int shi = num / 10 % 10;                // 123 / 10 = 12        12 % 10 = 2
13.         // 4：百位的计算：数值 / 100
14.         int bai = num / 100;                    // 123 / 100 = 1
15.         // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
16.         System.out.println("整数:"+num+" 个位为:" + ge);
17.         System.out.println("整数:"+num+" 十位为:" + shi);
18.         System.out.println("整数:"+num+" 百位为:" + bai);
20.     }
21. }

复制代码

“+”号的两种用法

• 第一种：对于+两边都是数值的话，+就是加法的意思。char类型参与算术运算，使用的是计算机底层对应的十进制数值。
  
• 第二种：对于+两边至少有一边是字符串得话，+就是拼接的意思。字符串可以使用 +号, 跟任意数据类型拼接，结果就是字符串。当连续进行“+”操作时，从左到右逐个执行。
  

代码示例

1. public class Demo02Operator {
2.     public static void main(String[] args) {
3.         
4.         //数学中的加法运算(数字相加,字符相加)
5.         System.out.println(5 + 5);// 10
6.         /*
7.             int + char ==> int + int ==> int
8.             需要:
9.                 char ==> int 查看ASCII码表 'A'对应65
10.         */
11.         System.out.println(5 + 'A');// 70
12.         /*
13.             自动类型转换中:
14.                 byte/short/char类型,只要参加运算,会自动转换为int类型
15.             char + char ==> int + int ==> int
16.             需要:
17.                 char ==> int 查看ASCII码表 'A'对应65
18.                 char ==> int 查看ASCII码表 'B'对应66
19.         */
20.         System.out.println('A' + 'B');// 131
22.         
23.         //字符串的拼接(把两个字符串连在一起),从左向右计算
24.         System.out.println("Hello" + "World"); //HelloWorld
26.         //先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
27.         //然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
28.         System.out.println("5+5=" + 5 + 5);//5+5=55
30.         //()的优先级是比较高的,所以先计算5+5 结果10
31.         //然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
32.         System.out.println("5+5=" + (5 + 5));//5+5=10
34.     }
35. }

复制代码

自增自减运算符

++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。只能操作变量，不能操作常量
​
单独使用（推荐使用）

变量在单独运算的时候，变量前++和变量后++，是没有任何区别的；

• 变量前++ ：例如 ++a
  
• 变量后++ ：例如 a++
  

代码示例

1. public static void main(String[] args) {
2.         // 定义一个int类型的变量a
3.         int a = 3;
4.         //++a;
5.         a++;
6.         // 无论是变量前++还是变量后++，结果都是4
7.         System.out.println(a);
8.     }

复制代码

复合使用

和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

• 变量前++ ：变量先自身加1，然后再取值。
  
• 变量后++ ：变量先取值，然后再自身加1。
  

1. public class Demo04Operator {
2.     public static void main(String[] args) {
3.         // 其他变量放在一起使用
4.         int x = 3;
5.         //int y = ++x;  y的值是4，x的值是4，
7.         // y的值是3，x的值是4
8.         int y = x++;
10.         System.out.println(x);//4
11.         System.out.println(y); //3
14.         // 和输出语句一起
15.         int z = 5;
17.         System.out.println(++z);//6
18.         System.out.println(z++);// 6
19.         System.out.println(z);//7
21.         int a = 1;
22.         //(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
23.         a = a++;
24.         System.out.println(a);//1
26.     }
27. }

复制代码

实际开发中强烈建议不要写这样的代码

1. public static void main(String[] args) {
2.         int x = 4;
3.         /*
4.             表达式(x++)+(++x)+(x*10)是从左到右计算的
5.             先计算(x++): 因为++在后面,先使用x的值4,然后x的值增加,变成5
6.             4 + (++x)+(x*10)
7.             接着计算(++x): 因为++在前面,先把x的值增加1,x变成6,然后再使用6
8.             4 + 6+(x*10)
9.             接着计算x*10 -->  6*10 结果: 60
10.             4 + 6 + 10 结果: 70
11.         */
12.         int y = (x++) + (++x) + (x * 10);
13.         System.out.println(x);//6
14.         System.out.println(y);//70
16.     }

复制代码

赋值运算符

• 赋值运算符，就是将符号右边的值，赋给左边的变量。 所有的赋值运算符的左边一定是一个变量，不能是常量。
  

​代码示例

1. /*
2.     基本赋值运算符: =
3.     复合赋值运算符:
4.         +=        a+=b        a=a+b
5.         -=        a-=b        a=a-b
6.         *=        a*=b        a=a*b
7.         /=        a/=b        a=a/b
8.         %=        a%=b        a=a%b
9. */
10. public class Demo03Operator {
11.     public static void main(String[] args) {
12.         //基本赋值运算符
13.         int a = 10, b = 20;
15.         //复合赋值运算符:
16.         a += b;//a = a + b
17.         System.out.println(a);//30
18.         System.out.println(b);//20
20.         int c = 30, d = 20;
21.         c %= d;//c = c % d
23.         System.out.println(c);//10
24.         System.out.println(d);//20
26.         short s = 1;
27.         /*
28.             +=,-=,/=,*=,%= 运算结果的数据类型和左侧变量的数据类型不一致,隐藏强制类型转换
29.         */
30.         s += 1;//s = (short)(s + 1);
31.         System.out.println(s);//2
33.     }
34. }

复制代码

注意事项：

• 扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。  
  
• 整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
  
• 运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。
  

例如：

1.         int j = 1;
2.         j += ++j * j++;//相当于  j = j + (++j * j++);
3.         System.out.println(j);//5

复制代码

关系运算符

• 关系运算符又可以叫比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false
  

代码示例 

1. ​
2. public class Demo05Operator {
3.     public static void main(String[] args) {
4.         int a = 10;
5.         int b = 20;
6.         System.out.println(a == b); // false
7.         System.out.println(a != b); // true
8.         System.out.println(a > b); // false
9.         System.out.println(a >= b); // false
10.         System.out.println(a < b); // true
11.         System.out.println(a <= b); // true
12.         // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
13.         boolean flag = a > b;
14.         System.out.println(flag);// 输出false
15.     }
16. }
18. ​

复制代码

注意事项：

• 其中>,=, b) & (a > c));  //false        System.out.println((a > b) & (a < c));  //false        System.out.println((a < b) & (a > c)); //false        System.out.println((a < b) & (a < c)); //true        // | “或”，或者的关系，只要表达式中有一个值为true，结果即为true        System.out.println((a > b) | (a > c)); //false        System.out.println((a > b) | (a < c)); //true        System.out.println((a < b) | (a > c)); //true        System.out.println((a < b) | (a < c)); //true        // ^ 异或；相同为false，不同为true        System.out.println((a > b) ^ (a > c)); //false        System.out.println((a > b) ^ (a < c));//true        System.out.println((a < b) ^ (a > c));//true        System.out.println((a < b) ^ (a < c));  //false        // ! 非；非false则true，非true则false        System.out.println(!false);   //true        System.out.println(!true); //false    }}[/code]短路逻辑运算符
  
  在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值 都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
  
  && 和& 区别：
  
  
  
  • &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
    
  || 和 | 区别：
  
  
  
  • ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。
    
  代码示例
  1. public class Demo6Operator {
  2.     public static void main(String[] args) {
  3.         int a = 3;
  4.         int b = 4;
  5.         int c = 5;
  7.         ////& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
  8.         System.out.println((a > b) & (a > c));  //false
  9.         System.out.println((a > b) & (a < c));  //false
  10.         System.out.println((a < b) & (a > c)); //false
  11.         System.out.println((a < b) & (a < c)); //true
  13.         // | “或”，或者的关系，只要表达式中有一个值为true，结果即为true
  14.         System.out.println((a > b) | (a > c)); //false
  15.         System.out.println((a > b) | (a < c)); //true
  16.         System.out.println((a < b) | (a > c)); //true
  17.         System.out.println((a < b) | (a < c)); //true
  20.         // ^ 异或；相同为false，不同为true
  21.         System.out.println((a > b) ^ (a > c)); //false
  22.         System.out.println((a > b) ^ (a < c));//true
  23.         System.out.println((a < b) ^ (a > c));//true
  24.         System.out.println((a < b) ^ (a < c));  //false
  27.         // ! 非；非false则true，非true则false
  28.         System.out.println(!false);   //true
  29.         System.out.println(!true); //false
  30.     }
  31. }

  复制代码
  三元运算符
  
  语法格式：
  
  
  
  
  • 数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;
    
  执行流程:
  
  
  
  • 计算布尔表达式1的结果,看是true还是false
    
  • 如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
    
  • 如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量
    
  执行流程图解:
  ​代码示例
  1. /*
  2. 逻辑运算符的短路效果
  3.     1.短路的逻辑运算符
  4.         (1)短路逻辑与&&: 左侧为false,右边不计算
  5.         (2)短路逻辑或||: 左侧为true,右侧不计算
  6.     2.特点:
  7.         (1)短路逻辑与&&: 和&结果是相同的,但是&&可以提高效率
  8.         (2)短路逻辑与||: 和|结果是相同的,但是||可以提高效率
  9. */
  10. public class Demo08Operator {
  11.     public static void main(String[] args) {
  13.         int a = 2;
  14.         /*
  15.             整个表达式(3>5)&&(++a>2)从左向右计算
  16.             先计算表达式3>5结果为false
  17.             因为两个表达式使用&&连接,左侧为false,已经决定了最终的结果为false,
  18.             不管右侧表达式(++a>2)的结果是true还是false,都无法改变&&的最终结果,
  19.             所以右侧表达式(++a>2)不进行计算
  20.          */
  21.         System.out.println((3 > 5) && (++a > 2));//false
  22.         System.out.println(a);//2: 说明++a没有计算,&&右侧的表达式没有执行
  24.         int b = 2;
  25.         /*
  26.             整个表达式(3>5)&(++b>2)从左向右计算
  27.             先计算表达式3>5结果为false
  28.             因为两个表达式使用&连接,左侧为false,虽然已经决定了最终的结果为false,
  29.             但是右侧表达式(++b>2)仍然要进行计算,所以b的值最终是3
  30.          */
  31.         System.out.println((3 > 5) & (++b > 2));//false
  32.         System.out.println(b);//3: 说明++b进行计算,&右侧的表达式执行了
  34.         System.out.println("-------------------");
  35.         int c = 2;
  36.         /*
  37.             整个表达式(3<5)||(++c>2)从左向右计算
  38.             先计算表达式3<5结果为true
  39.             因为两个表达式使用||连接,左侧为true,已经决定了最终的结果为true,
  40.             不管右侧表达式(++c>2)的结果是true还是false,都无法改变||的最终结果,
  41.             所以右侧表达式(++c>2)不进行计算
  42.          */
  43.         System.out.println((3 < 5) || (++c > 2));//true
  44.         System.out.println(c);//2: 说明++c没有计算,||右侧的表达式没有执行
  46.         int d = 2;
  47.         /*
  48.             整个表达式(3<5)|(++d>2)从左向右计算
  49.             先计算表达式3<5结果为true
  50.             因为两个表达式使用|连接,左侧为true,虽然已经决定了最终的结果为true,
  51.             但是右侧表达式(++d>2)仍然要进行计算,所以d的值最终是3
  52.          */
  53.         System.out.println((3 < 5) | (++d > 2));//true
  54.         System.out.println(d);//3: 说明++d进行计算,|右侧的表达式执行了
  56.     }
  57. }

  复制代码
  位运算（了解）
  
  效率很高，但是可读性不好。因为它是基于二进制补码直接运算的。关于&,|,^，看左右两边的操作数是boolean值，还是整数，来决定是逻辑运算符还是位运算符。常见的有以下几种位运算符
  
  <strong>左移：几位，就除以2的几次方
  
• 二进制补码右移n位，左边补0还是1，看最高位
  

无符号右移：>>>

• 运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后，变为正数
  

运算符优先级


我们遵循一个原则：

• 表达式不要写太复杂，可以分为多行
  
• 实际开发中都是使用小括号来调整运算优先级
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！