Java 运算符

算术运算符

除了常见的+ - * / % 还有自增自减-- ++运算符：

  • 前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。

    int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4

    int d = –c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

  • 后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算 实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class selfAddMinus{
        public static void main(String[] args){
            int a = 5;//定义一个变量；
            int b = 5;
            int x = 2*++a;
            int y = 2*b++;
            System.out.println("自增运算符前缀运算后a="+a+",x="+x);
            System.out.println("自增运算符后缀运算后b="+b+",y="+y);
        }
    }
    1
    2
    自增运算符前缀运算后a=6，x=12
    自增运算符后缀运算后b=6，y=10

关系运算符

运算符 描述 例子
== 检查如果两个操作数的值是否相等，如果相等则条件为真。 （A == B）为假。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 （A> B）为假。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 （A <B）为真。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 （A> = B）为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 （A <= B）为真。

位运算符

操作符 描述 例子
＆ 按位与，如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 按位或，如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101
^ 按位异或，如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001
〜 按位取反，运翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
-----------------
public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
}
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符 描述 例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 （A && B）为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 （A | | B）为真。
！ 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 ！（A && B）为真。 
1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}
a && b = false
a || b = true
!(a && b) = true

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (++a>10)&&(++a>10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}
使用短路逻辑运算符的结果为false
a的结果为6
public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}
使用短路逻辑运算符的结果为false
a的结果为5

赋值运算符

下面是Java语言支持的赋值运算符：

操作符 描述 例子
= 简单的赋值运算符，将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C
+ = 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A
- = 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C - A
* = 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/ = 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 C / = A，C 与 A 同类型时等价于 C = C / A
（％）= 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 C％= A等价于C = C％A
<< = 左移位赋值运算符 C << = 2等价于C = C << 2
>> = 右移位赋值运算符 C >> = 2等价于C = C >> 2
＆= 按位与赋值运算符 C＆= 2等价于C = C＆2
^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
| = 按位或赋值操作符 C | = 2等价于C = C | 2

条件运算符（三元运算符）?:

该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

1
variable x = (expression) ? value if true : value if false

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}
Value of b is : 30
Value of b is : 20

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）:

1
( Object reference variable ) instanceof  (class/interface type)

示例

1
2
3
4
5
6
7
8
9
public class InstacanceOf {
    public static void main(String[] args){
        String name = "James";
        boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
        System.out.println(result);
    }
}

true

Java运算符优先级

在 Java 中，运算符的优先级决定了在表达式中哪个运算符会先执行。了解这些优先级非常重要，可以帮助我们写出更清晰、更准确的代码。

1️⃣ 最高优先级（从高到低执行）

优先级 运算符 描述 结合方向
1 () 括号 左到右
[] 数组下标访问 左到右
. 对象成员访问、方法调用 左到右
2 ++、-- 后置自增、自减 左到右

2️⃣ 一元运算符

优先级 运算符 描述 结合方向
3 ++、-- 前置自增、自减 右到左
+、- 正、负号 右到左
~ 按位取反 右到左
! 逻辑非 右到左
(类型) 强制类型转换 右到左

3️⃣ 算术运算符

优先级 运算符 描述 结合方向
4 *、/、% 乘、除、取模 左到右
5 +、- 加、减 左到右

4️⃣ 位移运算符

优先级 运算符 描述 结合方向
6 << 左移 左到右
>> 右移（带符号） 左到右
>>> 无符号右移 左到右

5️⃣ 比较运算符

优先级 运算符 描述 结合方向
7 <、<=、>、>= 大小比较 左到右
8 instanceof 判断对象类型 左到右

6️⃣ 相等性运算符

优先级 运算符 描述 结合方向
9 == 判断相等 左到右
!= 判断不等 左到右

7️⃣ 位运算符

优先级 运算符 描述 结合方向
10 & 按位与 左到右
11 ^ 按位异或 左到右
12 ` ` 按位或

8️⃣ 逻辑运算符

优先级 运算符 描述 结合方向
13 && 逻辑与（短路） 左到右
14 ` `

9️⃣ 三目运算符

优先级 运算符 描述 结合方向
15 ? : 三目运算符 右到左

🔟 赋值运算符

优先级 运算符 描述 结合方向
16 = 赋值 右到左
+=、-= 加减赋值 右到左
*=、/=、%= 乘、除、取模赋值 右到左
&=、` =、^=` 位运算赋值
<<=、>>=、>>>= 位移赋值 右到左

💡 运算符优先级小技巧

  1. 括号优先：始终可以用 () 提高可读性，确保复杂表达式的执行顺序正确。

  2. 三目运算符结合方向是从右到左，容易忽略。

  3. 逻辑运算符短路特性：

    • &&：只要第一个条件为 false，后面的就不会执行。
  • ||：只要第一个条件为 true，后面的就不会执行。

✨ 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class OperatorPrecedenceExample {
    public static void main(String[] args) {
        int a = 5, b = 10, c = 15;

        // 算术运算符优先于比较运算符
        System.out.println(a + b > c); // (5 + 10) > 15 -> false

        // 位移运算符优先于按位与
        System.out.println(b >> 1 & a); // (10 >> 1) & 5 -> 5 & 5 -> 5 

        // 三目运算符结合方向从右到左
        int result = a > b ? b > c ? 100 : 200 : 300;
        System.out.println(result); // 输出：300

        // 赋值运算符结合方向从右到左
        int x, y, z;
        x = y = z = 10;
        System.out.println(x + ", " + y + ", " + z); // 输出：10, 10, 10
    }
}

📝 总结：

  • 括号 () 永远优先级最高。
  • 算术 > 位运算 > 比较 > 逻辑 > 赋值。
  • 短路逻辑运算符 && 和 || 会影响表达式执行顺序。
  • =、+=、-= 等赋值运算符的结合方向是从右到左。

如果你对某个运算符、执行顺序或某段代码的结果有疑问，咱们可以一起深入讨论！😊✨

来源：