Java 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

• 算术运算符
• 赋值运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 关系运算符
• 其他运算符

算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符
表格中的实例假设整数变量A = 10，B = 20

下面的简单示例程序演示了算术运算符

public class Test {
   public static void main(String[] args) {
      int a = 3;
      int b = 20;
      int c = 25;
      System.out.println("a + b = " + (a + b));
      System.out.println("a - b = " + (a - b));
      System.out.println("a * b = " + (a * b));
      System.out.println("b / a = " + (b / a));
      System.out.println("b % a = " + (b % a));
      // 查看 ++前缀 与 ++后缀 的不同
      System.out.println("a++ = " + (a++));
      System.out.println("++a = " + (++a));
      System.out.println("c-- = " + (c--));
      System.out.println("--c = " + (--c));
   }
}
/* 
以上实例编译运行结果如下：
a + b = 23
a - b = -17
a * b = 60
b / a = 6
b % a = 2
a++ = 3
++a = 5
c-- = 25
--c = 23
*/

自增自减运算符
自增（++） 与 自减（—）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数
前缀自增自减法(++a,—a): 先进行自增或者自减运算，再进行表达式运算

public class selfAddMinus {
   public static void main(String[] args) {
      int a = 3;    // 定义一个变量；
      int b = ++a;  // 自增运算
      int c = 3;
      int d = --c;  // 自减运算
      System.out.println("进行自增运算后的值等于" + b);
      System.out.println("进行自减运算后的值等于" + d);
   }
}

/* 
运行结果为：
进行自增运算后的值等于4
进行自减运算后的值等于2 
*/

• 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—): 先进行表达式运算，再进行自增或者自减运算 实例

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);
   }
}

/* 
自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10 
*/

⚠️注意：常量不可运算, 10++ 20— (这些都是错误的额

赋值运算符

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

面的简单示例程序演示了赋值运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序

public class Test {
   public static void main(String[] args) {
      int a = 10;
      int b = 20;
      int c = 0;
      c = a + b;
      System.out.println("c = a + b = " + c);
      c += a;
      System.out.println("c += a  = " + c);
      c -= a;
      System.out.println("c -= a = " + c);
      c *= a;
      System.out.println("c *= a = " + c);
      a = 10;
      c = 15;
      c /= a;
      System.out.println("c /= a = " + c);
      a = 10;
      c = 15;
      c %= a;
      System.out.println("c %= a  = " + c);
      c <<= 2;
      System.out.println("c <<= 2 = " + c);
      c >>= 2;
      System.out.println("c >>= 2 = " + c);
      c >>= 2;
      System.out.println("c >>= 2 = " + c);
      c &= a;
      System.out.println("c &= a  = " + c);
      c ^= a;
      System.out.println("c ^= a   = " + c);
      c |= a;
      System.out.println("c |= a   = " + c);
   }
}

/* 
c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10 
*/

关系运算符

下表为Java支持的关系运算符
表格中的实例假设整数变量A = 10，B = 20

public class Test {

   public static void main(String[] args) {
      int a = 10;
      int b = 20;
      System.out.println("a == b = " + (a == b));
      System.out.println("a != b = " + (a != b));
      System.out.println("a > b = " + (a > b));
      System.out.println("a < b = " + (a < b));
      System.out.println("b >= a = " + (b >= a));
      System.out.println("b <= a = " + (b <= a));
   }
}

/* 
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false 
*/

逻辑运算符

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

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，这时候就不会再判断第二个操作了

public class Test {
   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 
*/

⚠️ 解析：该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5
👍 推荐: 所以写代码的时候，最重要、最能影响程序运行的判断语句先写前边, 可以优化性能

位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型
位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A = 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A = 60 和变量 B = 13

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 
*/

&与&&的区别?
按位与&,无论做左边真假,右边都要执行
逻辑短路 &&,如果左边为假,右边为真 (则结果为假,右边不执行)

|与||的区别?
按位与|,无论做左边真假,右边都要执行
逻辑短路 ||,如果左边为真,右边为假（则结果为真,且右边不执行）

条件运算符

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

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

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);

      System.out.println(a > b ? a : b);    // 正确写法！
      // int result = 3 > 4 ? 2.5 : 10;     // 错误写法！
      // a > b ? a : b;                     // 错误写法！
   }
}


/* 
Value of b is : 30
Value of b is : 20 
*/

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）
instanceof运算符使用格式如下：

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

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真
下面是一个例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true
看下面的例子：

class Person { }

public class Student extends Person {
   public static void main(String[] args) {
      Person a = new Student();
      boolean result = a instanceof Student;
      System.out.println(result);
   }
}

/* 
true 
*/

Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大

• 例如: (1+3) ＋ (3+2)*2 这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14
• 再如: x = 7 + 3 2 这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 2得到6，然后再加7

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部