Java 运算符和表达式

一、Java 运算符分类：

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

1. 算术运算符

• 设变量 A = 10，变量 B = 20：

  操作符	描述	例子
  +	加法：相加运算符两侧的值	A + B 等于 30
  -	减法：左操作数减去右操作数	A – B 等于 -10
  *	乘法：相乘操作符两侧的值	A * B 等于 200
  /	除法：左操作数除以右操作数	B / A 等于 2
  ％	取余：左操作数除以右操作数的余数	B%A 等于 0
  ++	自增：操作数的值增加1	B++ 或 ++B 等于 21
  --	自减：操作数的值减少1	B-- 或 --B 等于 19

自增自减运算符

• 自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

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

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

• 示例：

  public class Test {
      public static void main(String[] args){
          int a = 5; //定义一个变量；
          int b = 5;
          // 拆分运算过程为: a=a+1=6; x=2*a=12
          int x = 2*++a;
          // 拆分运算过程为: y=2*b=2*5=10; b=b+1=6
          int y = 2*b++;
          System.out.println("a="+a+",x="+x); // a=6, x=12
          System.out.println("b="+b+",y="+y); // b=6, y=10
      }
  }
  

2. 关系运算符

• 设变量 A = 10，变量 B = 20：

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

• 示例：

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

3. 位运算符

• Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型(char)，和字节型 (byte) 等类型。位运算符作用在所有的位上，并且按位运算。

• 下表列出了位运算符的基本运算，设整数变量 A = 60（二进制：0011 1100），变量 B＝13（二进制：0000 1101）：

  操作符	描述	例子
  ＆	与：如果相对应位都是 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

• 位运算： &、|、^

  public class Test {
      public static void main(String[] args) {
        int x = 3 ;
          // 3的二进制数据：00000000 00000000 00000000 00000011
          int y = 6 ;
          // 6的二进制数据：00000000 00000000 00000000 00000110
          System.out.println(x & y);  // 2
          // 与操作的结果： 00000000 00000000 00000000 00000010
          System.out.println(x | y);  // 7
          // 或操作的结果： 00000000 00000000 00000000 00000111
          System.out.println(x ^ y);  // 5
          // 异或操作结果： 00000000 00000000 00000000 00000101
      }
  }
  

• 按位取反：~

  public class Test {
      public static void main(String[] args) {
        // -3的二进制数据：11111111 11111111 11111111 11111101
          int x = -3 ; 
          System.out.println(x + "的反码是：" + ~x);  // -3的反码是：2
      }
  }
  

  

• 左移操作： <<

  将运算数的二进制码整体左移指定位数，左移之后的空位使用 0 来填充。

  public class Test {
      public static void main(String[] args) {
          int x = 3 ;
          // 3的二进制数据：00000000 00000000 00000000 00000011
          System.out.println(x + "左移2位之后的内容：" + (x << 2)); // 12
      }
  }
  

  

• 右移操作（带符号）：>>

  public class Test {
      public static void main(String[] args) {
          int x = 3 ;
          // 3的二进制数据：00000000 00000000 00000000 00000011
          int y = -3 ;
          // -3的二进制数据：11111111 11111111 11111111 11111101
          System.out.println(x + "右移2位之后的内容：" + (x >> 2));  // 0
          System.out.println(y + "右移2位之后的内容：" + (y >> 2));  // -1
      }
  }
  

  

• 无符号右移：>>>

  使用此操作，将以 0 填充空出来的位

  public class Test {
      public static void main(String[] args) {
          int x = 3 ;
          // 3的二进制数据：00000000 00000000 00000000 00000011
          int y = -3 ;
          // -3的二进制数据：11111111 11111111 11111111 11111101
          System.out.println(x + "右移2位之后的内容：" + (x >>> 2)); // 0
          System.out.println(y + "右移2位之后的内容：" + (y >>> 2)); // 1073741823
      }
  }
  

4. 逻辑运算符

• 设置布尔变量 A 为真，变量 B 为假

  操作符	描述	例子
  &&	逻辑与：当且仅当两个操作数都为真，条件才为真。一假则假	（A && B）为假。
  | |	逻辑或：如果任何两个操作数任何一个为真，条件为真。一真则真	（A | | B）为真。
  ！	逻辑非：用来反转操作数的逻辑状态。如果条件为 true，则逻辑非运算符将得到 false。	！（A && B）为真。

• 示例：

  public class Test {
    public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       System.out.println("a && b = " + (a&&b)); // false
       System.out.println("a || b = " + (a||b) ); // true
       System.out.println("!(a && b) = " + !(a && b));  // true
    }
  }
  

• 短路逻辑运算符

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

  public class Test {
      public static void main(String[] args){
          int a = 5;//定义一个变量；
          // 首先判断 a<4 的结果为 false，则 b 的结果必定是 false，
          // 所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。
          boolean b = (a<4) && (a++<10);
          System.out.println("使用短路逻辑运算符的结果为"+b); // false
          System.out.println("a的结果为"+a); // 5
      }
  }
  

• 解析：该程序使用到了短路逻辑运算符 (&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

5. 赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	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

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b; // 30
        c += a ; // c = c+a = 30+10 = 40
        c -= a ; // c = c-a = 40-10 = 30
        c *= a ; // c = c*a = 30*10 = 300
        c /= a ; // c = c/a = 300/10 = 30
        c %= a ; //  c= c%a = 30%10 = 0      
        a = 10; 
        c = 15;
        c /= a ; // c = c/a = 15/10 = 1
        a = 10;
        c = 15;
        c %= a ; // c = c%a = 15%10 = 5
        c <<= 2 ; // c = c<<2 = 5<<2 = 20
        c >>= 2 ; // c = c>>2 = 20>>2 = 5
        c >>= 2 ; // c = c>>2 = 5>>2 = 1
        c &= a ; // c = c&a = 1&10 = (00000001 & 00001010=00000000) = 0
        c ^= a ; // c = c^a = 0^10 = (00000000 ^ 00001010=00001010) = 10
        c |= a ; // c = c|a = 10|10 = (00001010 | 00001010=00000000) = 0
    }
} 

6. 条件运算符

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

• 三元运算符格式：(关系表达式) ？表达式 1：表达式 2

  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 ); // 30
        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println( "Value of b is : " + b ); // 20
     }
  }
  

7. instanceof 运算符

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

• instanceof 运算符使用格式如下：

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

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

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

• 如果被比较的对象兼容于右侧类型，该运算符仍然返回 true。

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

二、Java 运算符优先级

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

  类别	操作符	关联性
  后缀	() [] . (点操作符)	左到右
  一元	expr++ expr--	从左到右
  一元	++expr --expr + - ～ ！	从右到左
  乘性	* /％	左到右
  加性	+ -	左到右
  移位	>> >>> <<	左到右
  关系	> >= < <=	左到右
  相等	== !=	左到右
  按位与	＆	左到右
  按位异或	^	左到右
  按位或	|	左到右
  逻辑与	&&	左到右
  逻辑或	| |	左到右
  条件	？：	从右到左
  赋值	= 、+ = 、- =、 * =、 / =、％=、 >> =、 << =、＆= 、^ = 、| =	从右到左
  逗号	，	左到右

注意：

1. 任何整数模 2 不是 0 就是 1，所以只要改变被模数就可以实现开关运算。

2. 逻辑运算符除了 ! 外都是用于连接两个 boolean 类型表达式。

3. 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

4. 对于除号 /，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

5. + 除字符串相加功能外，还能把非字符串转换成字符串。

6. 当 = 两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。

7. 三元运算符可简化 if-else 语句，三元运算符要求必须返回一个结果。

8. 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

9. 2 << 3 是算出 2 乘以 8 的最有效率的方法。

10. 无符号右移时在最高位添零。

11. Java 使用补码表示二进制数。

三、表达式

• Java 中的语句有很多种形式，表达式就是其中一种形式。表达式由操作数与运算符所组成。

• 操作数可以是常量、变量，也可以是方法；

• 运算符就是数学中的运算符号如 +、-、*、/、%等。以下面的表达式（z+100）为例，z 与 100 都是操作数，而 + 就是运算符。

  

• 表达式的计算结果必须是一个值，如果表达式是一个条件，就会产生逻辑值结果，即真或假。在其他情况下，值通常为计算的结果。