01、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

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

    1.1、算术运算符

    image.png ```java /* 运算符之一：算术运算符
      • / % (前)++ (后)++ (前)— (后)—

*/ class Day3Test{ public static void main(String[] args) {

  1.     //除号：/
  2.     int num1 = 12;
  3.     int num2 = 5;
  4.     int resule1 = num1 / num2;
  5.     System.out.println(resule1);    //2
  7.     int result2 = num1 / num2 * num2;
  8.     System.out.println(result2);
  10.     double result3 = num1 / num2;
  11.     System.out.println(result3);    //2.0
  13.     double result4 = num1 / num2 + 0.0;    //2.0
  14.     double result5 = num1 / (num2 + 0.0);    //2.4
  15.     double result6 = (double)num1 / num2;    //2.4
  16.     double result7 = (double)(num1 / num2);    //2.0
  17.     System.out.println(result5);
  18.     System.out.println(result6);
  20.     // %：取余运算
  21.     //结果的符号与被模数的符号相同
  22.     int m1 = 12;
  23.     int n1 = 5;
  24.     System.out.println("m1 % n1 = " + m1 % n1);
  26.     int m2 = -12;
  27.     int n2 = 5;
  28.     System.out.println("m2 % n2 = " + m2 % n2);
  30.     int m3 = 12;
  31.     int n3 = -5;
  32.     System.out.println("m3 % n3 = " + m3 % n3);
  34.     int m4 = -12;
  35.     int n4 = -5;
  36.     System.out.println("m4 % n4 = " + m4 % n4);
  38.     //(前)++ : 先自增1，后运算
  39.     //(后)++ ：先运算，后自增1
  40.     int a1 = 10;
  41.     int b1 = ++a1;
  42.     System.out.println("a1 = " + a1 + ",b1 = " + b1);
  44.     int a2 = 10;
  45.     int b2 = a2++;
  46.     System.out.println("a2 = " + a2 + ",b2 = " + b2);
  48.     int a3 = 10;
  49.     a3++;    //a3++;
  50.     int b3 = a3;
  52.     //注意点：
  53.     short s1 = 10;
  54.     //s1 = s1 + 1;    //编译失败

// s1 = (short)(s1 + 1); //正确的 s1++; //自增1不会改变本身变量的数据类型 System.out.println(s1);

  1.     //问题：
  2.     byte bb1 = 127;
  3.     bb1++;
  4.     System.out.println("bb1 = " + bb1);
  6.     //(前)-- :先自减1，后运算
  7.     //(后)-- ：先运算，后自减1
  9.     int a4 = 10;
  10.     int b4 = a4--;    //int b4 = --a4;
  11.     System.out.println("a4 = " + a4 + ",b4 = " + b4);
  12. }

}

  1. 算术运算符的注意问题
  3. - 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
  4. - 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：intx=3510;x=x/1000*1000; x的结果是？
  5. - “+”除字符串相加功能外，还能把非字符串转换成字符串.例如：System.out.println(“5+5=”+5+5); //打印结果是？5+5=55 ?
  6. ```java
  7. /*
  8. 练习：随意给出一个三位数的整数，打印显是它的个位数，十位数，百位数的值。
  9. 格式如下：
  10. 数字xxx的情况如下：
  11. 个位数：
  12. 十位数：
  13. 百位数：
  15. 例如：
  16. 数字153的情况如下：
  17. 个位数：3
  18. 十位数：5
  19. 百位数：1
  21. */
  22. class AriExer{
  23.     public static void main(String[] args){
  24.         int num = 187;
  25.         System.out.println("百位数：" + num/100);
  26.         System.out.println("十位数：" + num%100/10);
  27.         System.out.println("个位数：" + num%10);
  28.     }
  29. }

1.2、赋值运算符

  • 符号：=
    • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
    • 支持连续赋值。
  • 扩展赋值运算符：+=, -=, =, /=, %= ```java / 运算符之二：赋值运算符 += -= *= /=

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

  1.     int i2,j2;
  2.     //连续赋值
  3.     i2 = j2 = 10;
  5.     int i3 = 10,j3 = 20;
  7.     //***********************
  8.     int num1 = 10;
  9.     num1 += 2;    //num1 = num1 + 2;
  10.     System.out.println(num1);    //12
  12.     int num2 = 12;
  13.     num2 %= 5;    //num2 = num2 % 5;
  14.     System.out.println(num2);
  16.     short s1 = 10;
  17.     //s1 = s1 + 2;    //编译失败
  18.     s1 += 2;    //结论：不会改变变量本身的数据类型
  19.     System.out.println(s1);
  21.     //开发中，如果希望变量实现+2的操作，有几种方法？？？(int num = 10)
  22.     //方式一：num = num + 2;
  23.     //方式二：num += 2;(推荐)
  25.     //开发中，如果希望变量实现+1的操作，有几种方法？？？(int num = 10)
  26.     //方式一：num = num + 1;
  27.     //方式二：num += 1;
  28.     //方式三：num++;(推荐)
  29. }

}

  1. ```java
  2. class MkFan{
  3.     public static void main(String[] args) {
  4.         //练习1：
  5.         int i = 1;
  6.         i *= 0.1;
  7.         System.out.println(i);//
  8.         i++;
  9.         System.out.println(i);//
  11.         //练习2：
  12.         int m = 2;
  13.         int n1 = 3;
  14.         n1 *= m++; 
  15.         System.out.println("m=" + m);    //3
  16.         System.out.println("n1=" + n1);    //6
  18.         //练习3：
  19.         int n = 10;
  20.         n += (n++) + (++n);
  21.         System.out.println(n);    //32
  22.     }
  23. }

1.3、比较运算符

image.png

  • 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
  • 比较运算符“==”不能误写成“=” 。 ```java /* 运算符之三：比较运算符 == != > < >= <= 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

  1.     boolean b1 = true;
  2.     boolean b2 = false;
  3.     System.out.println(b2 == b1);    //false
  4.     System.out.println(b2 = b1);    //true
  5. }

}

  1. <a name="DWvDE"></a>
  2. ## 1.4、逻辑运算符
  4. - &—逻辑与
  5. - |—逻辑或
  6. - ！—逻辑非
  7. - && —短路与
  8. - ||—短路或
  9. - ^ —逻辑异或
  11. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12504300/1632560092386-c8070447-5737-4e4c-b977-d53b48710a9b.png#clientId=ub063f43b-8157-4&from=paste&id=u2c99f3bd&margin=%5Bobject%20Object%5D&name=image.png&originHeight=387&originWidth=1076&originalType=url&ratio=1&size=64149&status=done&style=none&taskId=u17e62f35-5351-4216-a13d-7a885e151e5)
  13. - 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
  14. - “&”和“&&”的区别：
  16. 单&时，左边无论真假，右边都进行运算；<br />双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
  18. - “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
  19. - 异或(^)与或( | )的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”!
  21. **练习**
  22. ```java
  23. /*
  24. 运算符之四：逻辑运算符
  25. & && | || ！ ^
  27. 说明：
  28. 1. 逻辑与运算符操作的都是boolean类型的变量
  30. */
  31. class LogicTest{
  32.     public static void main(String[] args){
  33.         //区分& 与 &&
  34.         //相同点1：& 与 && 的运算结果都相同
  35.         //相同点2：当符号左边是true时，二者都会执行符号右边的运算
  36.         //不同点：当符号左边是false时，&继续执行符号
  37.         //开发中，推荐使用&&
  38.         boolean b1 = false;
  39.         int num1 = 10;
  40.         if(b1 & (num1++ > 0)){
  41.             System.out.println("我现在在南京");
  42.         }else{
  43.             System.out.println("我现在在北京");
  44.         }
  45.         System.out.println("num1 = " + num1);
  47.         boolean b2 = false;
  48.         int num2 = 10;
  49.         if(b2 && (num2++ > 0)){
  50.             System.out.println("我现在在南京");
  51.         }else{
  52.             System.out.println("我现在在北京");
  53.         }
  54.         System.out.println("num2 = " + num2);
  56.         //区分：| 与 ||
  57.         //相同点1：| 与 || 的运算结果都相同
  58.         //相同点2：当符号左边是false时，二者都会执行符号右边的运算
  59.         //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
  60.         //开发中，推荐使用||
  61.         boolean b3 = true;
  62.         int num3 = 10;
  63.         if(b3 | (num3++ > 0)){
  64.             System.out.println("我现在在南京");
  65.         }else{
  66.             System.out.println("我现在在北京");
  67.         }
  68.         System.out.println("num3 = " + num3);
  70.         boolean b4 = true;
  71.         int num4 = 10;
  72.         if(b4 || (num4++ > 0)){
  73.             System.out.println("我现在在南京");
  74.         }else{
  75.             System.out.println("我现在在北京");
  76.         }
  77.         System.out.println("num4 = " + num4);
  78.     }
  79. }
  1. class LogoinTest{
  2.     public static void main(String[] args){
  3.         boolean x = true;
  4.         boolean y = false;
  5.         short z = 42;
  6.         //if(y == true)
  7.         if((z++==42)&&(y=true))z++;
  8.         if((x=false)||(++z==45)) z++;
  9.         System.out.println("z=" + z);    //46
  10.     }
  11. }

1.5、位运算符

1、位运算是直接对整数的二进制进行的运算
image.png
2、注意：无<<<

  1. /*
  2. 运算符之五：位运算符(了解)
  4. 结论：
  5. 1.位运算符操作的都是整型的数据变量
  6. 2.<< : 在一定范围内，每向左移一位，相当于 * 2
  7.   >> : 在一定范围内，每向右移一位，相当于 / 2
  9. 面试题：最高效的计算2 * 8 ？    2 << 3 或 8 << 1
  10. */
  11. class BitTest{
  12.     public static void main(String[] args){
  13.         int i = 21;
  14. //        i = -21;
  15.         System.out.println("i << 2 :" + (i << 2));
  16.         System.out.println("i << 3 :" + (i << 3));
  17.         System.out.println("i << 20 :" + (i << 20));
  18.         System.out.println("i << 27 :" + (i << 27));
  19.         int m = 12;
  20.         int n = 5;
  21.         System.out.println("m & n :" + (m & n));
  22.         System.out.println("m & n :" + (m | n));
  23.         System.out.println("m & n :" + (m ^ n));
  24.         //练习：交换两个变量的值
  25.         int num1 = 10;
  26.         int num2 = 20;
  28.         //方式一：
  29.     //    int tent = num1;
  30.     //    num1 = num2;
  31.     //    num2 = tent;
  33.         //方式二：
  34.         //好处：不用定义临时变量
  35.         //弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
  36. //        num1 = num1 + num2;
  37. //        num2 = num1 - num2;
  38. //        num1 = num1 - num2;
  40.         //方式三：使用位运算
  41.         num1 = num1 ^ num2;
  42.         num2 = num1 ^ num2;
  43.         num1 = num1 ^ num2;
  45.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  46.     }
  47. }

image.png
image.png
image.png

  1. class BitTest{
  2.     public static void main(String[] args){
  3.         //练习：交换两个变量的值
  4.         int num1 = 10;
  5.         int num2 = 20;
  7.         //方式一：
  8.     //    int tent = num1;
  9.     //    num1 = num2;
  10.     //    num2 = tent;
  12.         //方式二：
  13.         //好处：不用定义临时变量
  14.         //弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
  15. //        num1 = num1 + num2;
  16. //        num2 = num1 - num2;
  17. //        num1 = num1 - num2;
  19.         //方式三：使用位运算
  20.         num1 = num1 ^ num2;
  21.         num2 = num1 ^ num2;
  22.         num1 = num1 ^ num2;
  24.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  25.     }
  26. }

1.6、三元运算符


image.png

  1. /*
  2. 运算符之六：三元运算符
  3. 1.结构：(条件表达式)？表达式1 : 表达式2
  4. 2. 说明
  5. ① 条件表达式的结果为boolean类型
  6. ② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  7.   如果表达式为true,则执行表达式1
  8.   如果表达式为false,则执行表达式2
  9. ③ 表达式1 和表达式2要求是一致的。
  10. ④ 三元运算符是可以嵌套的
  11. 3. 凡是可以使用三元运算的地方，都是可以改写if-else。
  12.    反之，则不一定成立！！！
  13. */
  14. class SanTest{
  15.     public static void main(String[] args) {
  16.         //获取两个整数的最大值
  17.         int m = 12;
  18.         int n = 5;
  19.         int max = (m > n)? m : n;
  20.         System.out.println(max);
  22.         double num = (m > n) ? 2 : 1.0;
  23.         //(m > n) ? 2 : "n大";    //编译错误
  25.         //****************************************
  26.         String str = (m > n) ? "m大" : ((m == n)? "m和n相等" : "n大");
  27.         System.out.println(str);
  29.         //****************************************
  30.         //获取三个数中的最大值
  31.         int n1 = 12;
  32.         int n2 = 30;
  33.         int n3 = -43;
  35.         int max1 = (n1 > n2) ? n1 : n2;
  36.         int max2 = (max1 > n3) ? max1 : n3;
  37.         System.out.println("三个数中的最大值是：" + max2);
  39.         //此方法：pass
  40.         int max3 = (((n1 > n2)? n1 : n2) > n3) ?((n1 > n2) ? n1 : n2) : n3;
  41.         System.out.println("三个数中的最大值是：" + max3);
  43.         //改写成if-else
  44.         if(m > n){
  45.             System.out.println(m);
  46.         }else{
  47.             System.out.println(n);
  48.         }
  49.     }
  50. }

02、运算符的优先级

  • 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
  • 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

运算符 - 图8