目录
一、算数运算符
二、关系运算符
三、逻辑运算符
四、赋值运算符
五、三元运算符
六、位运算符
七、括号与运算符级别
一、算数运算符
| 算数运算符 | 用途 |
| + | 加法运算，字符串连接运算，正号 |
| - | 减法运算，负号 |
| * | 乘法运算 |
| / | 除法运算，当参与 / 运算的两个操作数都是整数时， 表示整数除法；否则， 表示浮点除法。整数被 0 除将会产生一个异常， 而浮点数被 0 除将会得到无穷大或 NaN 结果。 |
| % | 取模运算，两个数字相除取余数 公式：a % b = a - a / b * b 当a是小数时，公式：a % b = a - (int)a / b * b |
| ++、-- | 自增自减运算 |
++ 运算，变量自己增长1。 -- 运算，变量自己减少1，用法与 ++ 一致。
- 独立运算： 变量在独立运算时， 前++（i++） 和 后++（++i） 没有区别。
- 混合运算：
-
- 前++（i++），变量先+1，然后使用结果。 【先加后用】
- 后++（++i），先使用变量本来的数值，然后变量+1。【先用后加】
+ 符号在字符串中的操作：
- + 符号在遇到字符串的时候，表示连接、拼接的含义。
-
- "a"+"b"的结果是“ab”，连接含义。
运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
public class ArithmeticOperator{
public static void main(String[] args) {
System.out.println(10 / 4); // 2 整数运算结果也是整数
System.out.println(10.0 / 4); // 2.5
double a = 10 / 4; // 先整数运算10/4得到2，再转换为double类型，得到2.0
System.out.println(a);
// 取模 %
// 公式：a % b = a - a / b * b
System.out.println(10 % 3); // 1
System.out.println(-10 % 3); // -1
// -10 - (-10) / 3 * 3
// -10 - (-3) * 3
// -10 - (-9)
// -10 + 9
// -1
System.out.println(10 % -3); // 1
// 10 - 10 / (-3) * (-3)
// 10 - (-3) * (-3)
// 10 - 9
// 1
System.out.println(-10 % -3); // -1
System.out.println(-10.5 % 3); // -1.5
// -10.5 - (int)(-10.5) / 3 * 3
// -10.5 - (-10) / 3 * 3
// -10.5 - (-3) * 3
// -10.5 - (-9)
// -10.5 + 9
// -1.5
// ++
int i = 10;
i++;
++i;
System.out.println("i = " + i);
// 作为表达式使用
// 前++： ++i 先自增，再使用
// 后++： i++ 先使用，后自增
int j = 8;
// int k = ++j; // 等价于 j = j + 1; k = j; 两条语句
int k = j++; // 等价于 k = j; j = j + 1; 两条语句
System.out.println("k = " + k + ", j = " + j);
}
}
练习
int i = 1; i = i++; System.out.println(i); // i 的输出结果为【1】
int i = 1; i = ++i; System.out.println(i); // i 的输出结果为【2】
二、关系运算符
| 运算符 | 描述 |
| == | 比较符号两边数据是否相等，相等结果是true |
| < | 比较符号左边的数据是否小于右边的数据，如果小于结果是true |
| > | 比较符号左边的数据是否大于右边的数据，如果大于结果是true |
| <= | 比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true |
| >= | 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true |
| != | 不等于符号 ，如果符号两边的数据不相等，结果是true |
| instanceof | 判断是否为类的对象 "aaa" instanceof String 结果为true |
关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。
关系运算符组成的表达式，我们称为关系表达式。
public class RelationalOperator{
public static void main(String[] args) {
int a = 9;
int b = 8;
System.out.println(a > b); // true
System.out.println(a >= b); // true
System.out.println(a < b); // false
System.out.println(a <= b); // false
System.out.println(a == b); // false
System.out.println(a != b); // false
boolean flag = a > b; // true
System.out.println("flag = " + flag);
}
}
因为浮点数运算是近似值，所以比较是否相等时使用“==”结果不准确。例如比较a和b是否相等，可以这样：
if (a - b < 0.00000001) {}
当运算的值小于某一定程度的时候，认为他是相等的。
三、逻辑运算符
| 运算符 | 描述 |
| && 短路与 | 两边都是true，结果是true；一边是false，结果是false。符号左边是false，右边不再运算，效率高 |
| || 短路或 | 两边都是false，结果是false；一边是true，结果是true。符号左边是true，右边不再运算，效率高 |
| & 逻辑与 | 两边都是true，结果是true；一边是false，结果是false。符号左边是false，右边继续运算，效率低 |
| | 逻辑或 | 两边都是false，结果是false；一边是true，结果是true。符号左边是true，右边继续运算，效率低 |
| ！ 取反 | ! true 结果是false；! false结果是true |
| ^ 异或 | 逻辑异或，当两边值不同时，结果为 true, 否则为 false |
与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。可以有多个条件：条件A && 条件B && 条件C。
| a | b | a&b | a&&b | a|b | a||b | !a | a^b |
| true | true | true | true | true | true | false | false |
| true | false | false | false | true | true | false | true |
| false | true | false | false | true | true | true | true |
| false | false | false | false | false | false | true | false |
public class LogicOperator{
public static void main(String[] args) {
int age = 50;
if (age > 20 && age < 90) {
System.out.println("ok100");
}
if (age > 20 & age < 90) {
System.out.println("ok200");
}
int a = 4;
int b = 9;
if (a < 1 && ++b < 20) {
System.out.println("ok300");
}
System.out.println("b = " + b); // b = 9
int c = 4;
int d = 9;
if (c < 1 & ++d < 20) {
System.out.println("ok400");
}
System.out.println("d = " + d); // d = 10
int e = 4;
int f = 9;
if (e > 1 || ++f < 20) {
System.out.println("ok500");
}
System.out.println("f = " + f); // f = 9
int g = 4;
int h = 9;
if (g > 1 | ++h < 20) {
System.out.println("ok400");
}
System.out.println("h = " + h); // h = 10
System.out.println(!(60 > 20)); // false
System.out.println(!(60 < 20)); // true
boolean i = (10 > 1) ^ (3 < 5);
System.out.println("i = " + i); // false
boolean j = (10 > 1) ^ (3 > 5);
System.out.println("j = " + j); // true
}
}
练习
boolean x = true;
boolean y = false;
short z = 46;
if ((z++ == 46) && (y = true)) {
z++;
}
if ((x = false) || (++z) == 49) {
z++;
}
System.out.println("z = " + z); // 50
四、赋值运算符
赋值运算符，就是将符号右边的值，赋给左边的变量。如果运算符得到一个值， 其类型与左侧操作数的类型不同， 就会发生强制类型转换。
| 赋值运算符 | 描述 |
| = | 等于号 |
| += | 加等于 x += 4; 等价于：x = x + 4; |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
运算顺序从右往左int num = a + b + c;
赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
复合赋值运算符会进行类型转换。 byte b = 2; b+=3; b++;
public class AssignOperator{
public static void main(String[] args) {
int n1 = 10;
n1 += 4;
System.out.println(n1); // 14
n1 /= 3;
System.out.println(n1); // 4
byte b = 3;
b += 2; // 等价于 b = (byte)(b + 2);
b++; // 等价于 b = (byte)(b + 1);
}
}
五、三元运算符
条件表达式 ? 表达式1 : 表达式2;
三元运算符计算方式：
- 条件表达式结果是true，三元运算符整体结果为表达式1。
- 条件表达式结果是false，三元运算符整体结果为表达式2。
必须同时保证表达式A和表达式B都符合左侧数据类型的要求。三元运算符的结果必须被使用。
三元运算符可以转成 if--else 语句
表达式 1 和表达式 2 要为可以赋给接收变量的类型（或可以自动转换）
public class TernaryOperator {
public static void main(String[] args) {
int a = 10;
int b = 99;
// 1. a > b 为false
// 2. 得到表达式 b--
// 3. 因为是 后--，先将b的值赋给result
// 4. result的值为99，b的值为98
int result = a > b ? a++ : b--;
System.out.println("result = " + result);
System.out.println("b = " + b);
}
}
六、位运算符
处理整型类型时，可以直接对组成整型数值的各个位完成操作。这意味着可以使用掩码技术得到整数中的各个位。
| 运算符 | 描述 | |
| & ("and") | 按位与 | 两位全为1，结果为1，否则为0 |
| | ("or") | 按位或 | 两位有一个为1，结果为1，否则为0 |
| ^ ("xor") | 按位异或 | 两位一个为0，一个为1，结果为1，否则为0 |
| ~ ("not") | 按位取反 | 0为1，1为0 |
关于二进制和十进制的相互转换可以看这篇文章：
public class TernaryOperatorDetail {
public static void main(String[] args) {
System.out.println(2 & 3);
System.out.println(~-2);
System.out.println(~2);
}
}
| 运算符 | 描述 | |
| >> | 算数右移 | 低位溢出，符号位不变，并用符号位补溢出的高位 |
| << | 算数左移 | 符号位不变，低位补0 |
| >>> | 无符号右移、逻辑右移 | 低位溢出，高位补0 |
public class TernaryOperatorDetail {
public static void main(String[] args) {
System.out.println(1 >> 2);
System.out.println(4 << 3);
}
}
这些运算符按位模式处理。例如， 如果 n 是一个整数变量，而且用二进制表示的 n 从右边数第 4 位为 1，则
int fourthBitFromRight = (n & 0b1000) / 0b1000;会返回 1，否则返回 0。利用 & 并结合使用适当的 2 的幂， 可以把其他位掩掉， 而只保留其中的某一位。
& 和丨运算符应用在布尔值上时也会得到一个布尔值。这些运算符与 && 和 || 运算符很类似，不过 & 和丨运算符不采用“ 短路” 方式来求值， 也就是说，得到计算结果之前两个操作数都需要计算。
>>和<<运算符将位模式左移或右移。需要建立位模式来完成位掩码时， 这两个运算符会很方便：
int fourthBitFromRight = (n & (1<< 3)) >> 3;
最后，>>> 运算符会用 0 填充高位，这与>>不同，它会用符号位填充高位。不存在<<<运算符。
七、括号与运算符级别
从上到下优先级从高到低
| 运算符 | 结合性 |
| [ ] . ( ) (方法调用) | 从左向右 |
| ! ~ ++ -- + (一元运算符) - (一元运算符) ( ) (强制类型转换) new | 从右向左 |
| * / % | 从左向右 |
| + - | 从左向右 |
| << >> >>> | 从左向右 |
| < <= > >= instanceof | 从左向右 |
| == != | 从左向右 |
| & | 从左向右 |
| ^ | 从左向右 |
| | | 从左向右 |
| && | 从左向右 |
| || | 从左向右 |
| ? : | 从左向右 |
| = += -= *= /= %= &= |= ^= <<= >>= >>>= | 从右向左 |
