一、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 >= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 （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=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 + - ～ ！ 从右到左 乘性 * /％ 左到右 加性 + - 左到右 移位 >> >>> << 左到右 关系 > >= < <= 左到右 相等 == != 左到右 按位与 ＆ 左到右 按位异或 ^ 左到右 按位或 | 左到右 逻辑与 && 左到右 逻辑或 | | 左到右 条件 ？： 从右到左 赋值 = 、+ = 、- =、 * =、 / =、％=、 >> =、 << =、＆= 、^ = 、| = 从右到左 逗号 ， 左到右
注意：
任何整数模 2 不是 0 就是 1，所以只要改变被模数就可以实现开关运算。
逻辑运算符除了 ! 外都是用于连接两个 boolean 类型表达式。
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号
/，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。+除字符串相加功能外，还能把非字符串转换成字符串。当
=两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。三元运算符可简化 if-else 语句，三元运算符要求必须返回一个结果。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
2 << 3 是算出 2 乘以 8 的最有效率的方法。
无符号右移时在最高位添零。
Java 使用补码表示二进制数。
三、表达式
Java 中的语句有很多种形式，表达式就是其中一种形式。表达式由操作数与运算符所组成。
操作数可以是常量、变量，也可以是方法；
-
运算符就是数学中的运算符号如
+、-、*、/、%等。以下面的表达式（z+100）为例，z与100都是操作数，而+就是运算符。 表达式的计算结果必须是一个值，如果表达式是一个条件，就会产生逻辑值结果，即真或假。在其他情况下，值通常为计算的结果。