【Java SE语法篇】3.运算符

📚博客主页：爱敲代码的小杨.

✨专栏：《Java SE语法》

❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️

文章目录

• 1. 什么是运算符
• 2. 算术运算符
• • 2.1 基本四则运算：加减乘除求模（+，-，*，/，%）
  • 2.2 结合赋值和运算符（+=，-=，*=，/=，%=）
  • 2.3 自增/自减运算符（++，–）
• 3. 关系运算符
• 4. 逻辑运算符（重点）
• • 4.1 逻辑与 &&
  • 4.2 逻辑或 ||
  • 4.3 逻辑非 !
• 5. 位运算符
• • 5.1 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0
  • 5.2 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
  • 5.3 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
  • 5.4 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1
• 6. 移位运算符（了解）
• • 6.1 左移 <<: 最左侧位不要了, 最右侧补 0
  • 6.2 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
  • 6.3 无符号右移 >>>: 最右侧位不要了, 最左侧补 0.
• 7. 条件运算符
• 8. 运算符的优先级

1. 什么是运算符

计算机的最基本的用途之一就是执行数学运算，比如：

int a = 10;
 int b = 20;
 a + b;
 a < b;

上述 + 和 < 等就是运算符，即：对操作数进行操作时的符号，不同运算符操作的含义不同。

作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。Java中运算符可分为以下：算术运算符(+ – * /)、关系运算符( ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等

2. 算术运算符

2.1 基本四则运算：加减乘除求模（+，-，*，/，%）

int a = 20;
int b = 10;
System.out.println(a + b);     // 30
System.out.println(a - b);     // 10
System.out.println(a * b);     // 200
System.out.println(a / b);     // 2
System.out.println(a % b);     // 0 --->模运算相当于数学中除法的余数

【注意】：

• 都是二元运算符，使用时必须要有左右两个操作数

• int / int 结果还是int类型，而且会向下取整

  int a = 3;
   int b = 2;
  // 在数学中应该是1.5  但是在Java中输出结果为1  会向下取整，即小数点之后全部舍弃掉了
  System.out.println(a / b); // 1
  
  // 如果要得到数学中的结果，可以使用如下方式
  double d = a * 1.0 / b;
  System.out.println(d);// 1.5
  

• 做除法和取模时，右操作数不能为0

  

• % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

  System.out.println(11.5 % 2.0);// 1.5
  

• 两侧操作数类型不一致时，向类型大的提升

  System.out.println(1 + 0.2);   // +的左侧是int，右侧是double，在加之前int被提升为double
  // 1.2
  

2.2 结合赋值和运算符（+=，-=，*=，/=，%=）

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数.

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a);   // 输出3

a -= 1;// 相当于 a = a - 1
System.out.println(a);   // 输出2

a *= 3;// 相当于 a = a * 3
System.out.println(a);   // 输出6

a /= 3;// 相当于 a = a / 3
System.out.println(a);   // 输出2

a %= 3;                  // 相当于 a = a % 2
System.out.println(a);   // 输出2

【注意】：只有变量才能使用该运算符，常量不能使用。

2.3 自增/自减运算符（++，–）

++是一种自增的操作符，又分为前置++和后置++，–是一种自增的操作符，又分为前置–-和后置–-。

1. 前置++

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = ++a;// ++的操作数是a，是放在a的前面的，就是前置++
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 11 , b = 11
    }
}

计算口诀：先 +1，后使用

a原来是10，先 +1，后a变成了11，再使用赋值给b，b得到的也是11，所以计算后，a和b都是11，等价于这样的代码：

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        a += 1;
        int b = a;
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 11 , b = 10
    }
}

2. 后置++

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = a++;// ++的操作数是a，是放在a的后面的，就是后置++
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 11 , b = 10
    }
}

计算口诀：先使用，后 +1

a原来是10，先使用，把a赋值给b，b变成了10，后a+1变成了10，所以计算后，a=11,b=10，等价于这样的代码：

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = a;
        a += 1;
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 11 , b = 10
    }
}

3. 前置–

和前置++同理，只是换成了-1

计算口诀：先 -1，后使用

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = --a;// --的操作数是a，是放在a的前面的，就是前置--
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 9 , b = 9
    }
}

4. 后置–

和后置++同理，只是换成了-1

计算口诀：先使用，后-1

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = a--;// --的操作数是a，是放在a的后面的，就是后置--
        System.out.printf("a = %d , b = %d",a , b);
        // 运行结果：a = 9 , b = 10
    }
}

【注意】：

• 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1
• 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

3. 关系运算符

关系远算符有6个：（==，!=，>，=，<=），其结果是true和flase

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
//在Java中 == 表示相等
System.out.println(a == b);       // false
System.out.println(a != b);       // true
System.out.println(a  b);        // false
System.out.println(a = b);       // false

int a = 1;
int b = 2;

System.out.println(a == 1 && b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100);  // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2);  // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

int a = 1;
int b = 2;

System.out.println(a == 1 || b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100);  // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2);  // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

int a = 1;
System.out.println(!(a == 1));   // a == 1 为true，取个非就是false
System.out.println(!(a != 1));  // a != 1 为false，取个非就是true

4. 短路求值

&& 和 || 遵守短路求值的规则.

```java
System.out.println(10 > 20 && 10 / 0 == 0);             // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0);             // 打印 true

int a = 10;
int b = 20;
System.out.println(a & b);
// 0000 1010  10的二进制
// 0001 0100  20的二进制
// 0000 0000

int a = 10;
int b = 20;
System.out.println(a | b);
// 0000 1010
// 0001 0100
// 0001 1110

int a = 0xf;
System.out.printf("%x\n", ~a);

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);

int a = 0x10;
System.out.printf("%x\n", a << 1); 
// 运行结果(注意, 是按十六进制打印的)
//20

int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
//8

int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果(注意, 是按十六进制打印的)
//ffff8000

int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
//7ffffff

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);