运算分类 及 运算符优先级（Java 版）
目录
- 运算分类 及 运算符（Java 版）
-
- 算术运算（四则运算）
-
- 加法运算、减法运算
- 乘法运算、除法运算
- 模运算（求余）
- 自增、自减
- 关系运算
-
- 大于、小于、等于、不等于
- 大于等于、小于等于
- 类型比较 instanceof
- 逻辑运算（布尔运算）
-
- 位运算
-
- 按位与运算、按位或运算
- 同或运算、异或运算、取反运算
- 短路与、短路或、按位非运算
- 条件运算
- 位移运算
-
- 左移、右移
- 无符号右移
- 总结
-
- 复合赋值运算符
-
- 算术运算
- 逻辑运算
- 运算符的优先级
运算分类 及 运算符（Java 版）
-
运算：数学上，运算是一种行为，通过已知量的可能的组合，获得新的量。 -
运算的
本质：是集合之间的映射。
算术运算（四则运算）
-
算术运算：是加法、减法、乘法和除法四种运算的统称。 -
算术运算：通常是对实数或复数进行的。 -
属于某个数集的两个数，经过
算术运算，可以确定出这个数集的第三个数。
加法运算、减法运算
加法(+)：把两个数合并成一个数的运算。
@SpringBootTest
public class OperationTest {
@Test
public void addition() {
// 和
int tmp = 1 + 2;
System.out.println(tmp);
}
}
减法(-)：在已知两个加数的和与其中的一个加数，求另一个加数的运算。
@SpringBootTest
public class OperationTest {
// a 是 加数和，b 是已知的 加数，tmp 是要求的 另一个加数
@Test
public void subtraction() {
int a = 4;
int b = 2;
// 差
int tmp = a - b;
System.out.println(tmp);
}
}
减法与加法互为逆运算。
乘法运算、除法运算
-
乘法(*)：求两个数乘积的运算。-
一个数乘整数，是求几个相同加数和的简便运算。
-
一个数乘小数，是求这个数的十分之几、百分之几、千分之几……是多少。
-
一个数乘分数，是求这个数的几分之几是多少。
-
@SpringBootTest
public class OperationTest {
@Test
public void multiplication() {
// 乘积
int tmp = 4 * 3;
System.out.println(tmp);
double tmp1 = 4 * 0.5;
System.out.println(tmp1);
}
}
-
除法(/)：已知两个因数的积与其中的一个因数，求另一个因数的运算。（整除）- 整除就是一个数除以另一个数，刚刚好的倍数，这里没有四舍五入，不够一倍的都将舍去。
@SpringBootTest
public class OperationTest {
// a 是 因数积，b 是已知的 因数，tmp 是要求的 另一个因数
@Test
public void division() {
// 被除数
int a = 4;
// 除数
int b = 2;
// 商
int tmp = a / b;
System.out.println(tmp);
}
}
-
除法与乘法互为逆运算。 -
乘法是加法的简便运算，除法是减法的简便运算。
模运算（求余）
模法运算(%)：指一个数除以另一个数，不够除的部分就是余数，就是求余的结果。
@SpringBootTest
public class OperationTest {
// a 是 因数积，b 是已知的 因数，tmp 是要求的 余数
@Test
public void remainder() {
// 被除数
int a = 4;
// 被除数
int b = 3;
// 余数
int tmp = a % b;
System.out.println(tmp);
}
}
自增、自减
-
自增(++)：一个数是变量，一个数是 1 的加法运算。 -
自减(--)：加数的和是变量，已知加数为 -1 的减法运算。
@SpringBootTest
public class OperationTest {
public static void autoIncrement() {
for (int i = 0; i < 5; i++) {
System.out.print(i + " ");
}
System.out.println();
int a = 3;
int b = a++;
System.out.println("3++：" + b);
System.out.println("a：" + a);
int d = 3;
int c = ++d;
System.out.println("++3：" + c);
System.out.println("d：" + d);
}
public static void autoReduction() {
for (int i = 4; i >= 0; i--) {
System.out.print(i + " ");
}
System.out.println();
int a = 3;
int b = a--;
System.out.println("3--：" + b);
System.out.println("a：" + a);
int d = 3;
int c = --d;
System.out.println("--3：" + c);
System.out.println("d：" + d);
}
}
关系运算
大于、小于、等于、不等于
-
大于(>)：前一个变量大于后一个变量时，结果为 true；否则，结果为 false。 -
小于(<)：前一个变量小于后一个变量时，结果为 true；否则，结果为 false。 -
等于(==)：前一个变量等于后一个变量时，结果为 true；否则，结果为 false。 -
不等于(!=)：前一个变量不等于后一个变量时，结果为 true；否则，结果为 false。
@SpringBootTest
public class OperationTest {
public static void compare() {
boolean tmp = 2 > 3;
System.out.println(" 2 大于 3：" + tmp);
boolean tmp1 = 2 < 3;
System.out.println(" 2 小于 3：" + tmp1);
boolean tmp2 = 2 == 3;
System.out.println(" 2 等于 3：" + tmp2);
boolean tmp3 = 2 != 3;
System.out.println(" 2 不等于 3：" + tmp3);
}
}
大于等于、小于等于
-
大于等于(>=)：前一个变量大于后一个变量时 或者 前一个变量等于后一个变量时，结果为 true；否则，结果为 false。 -
小于等于(<=)：前一个变量小于后一个变量时 或者 前一个变量等于后一个变量时，结果为 true；否则，结果为 false。
@SpringBootTest
public class OperationTest {
public static void compareOne() {
boolean tmp = 2 >= 3;
System.out.println(" 2 大于等于 3：" + tmp);
boolean tmp1 = 2 <= 3;
System.out.println(" 2 小于等于 3：" + tmp1);
boolean tmp2 = 3 >= 2;
System.out.println(" 3 大于等于 2：" + tmp2);
boolean tmp3 = 3 <= 2;
System.out.println(" 3 小于等于 2：" + tmp3);
}
}
类型比较 instanceof
类型比较(instanceof)：判断其左边变量（左边对象）是否为其右边变量（右边类）的实例。
@SpringBootTest
public class OperationTest {
public static void instanceofCompare() {
String str = "aa";
boolean tmp = str instanceof String;
System.out.println("'aa' instanceof String：" + tmp);
}
}
逻辑运算（布尔运算）
-
逻辑运算：用数学方法研究逻辑问题。用来测试真假值。 -
用
等式表示判断，把推理看作等式的变换；不依赖人们对符号的解释，只依赖于符号的组合规律。 -
布尔值：有且仅有 true、false 两个，且互为相反数。 -
逻辑运算既可以用于 布尔值 之间的运算，也可以用于 数值 之间。
位运算
-
整数之间进行
逻辑运算时，需要转换成 二进制 进行。相应的，这就是位运算。 -
位运算就是直接对整数在内存中的二进制位进行操作。
按位与运算、按位或运算
按位与(&)：两个变量都是 true 时，结果才为 true；否则结果为 false。
@SpringBootTest
public class OperationTest {
public static void and() {
boolean tmp = true & false;
System.out.println("true & false 结果：" + tmp);
boolean tmp1 = true & true;
System.out.println("true & true 结果：" + tmp1);
boolean tmp2 = false & true;
System.out.println("false & true 结果：" + tmp2);
boolean tmp3 = false & false;
System.out.println("false & false 结果：" + tmp3);
// 1D = 01B（十进制数 1 的二进制是 01）, 2D = 10B
// 故，01B & 10B = 00B = 0D
int tmp4 = 1 & 2;
System.out.println("1 & 2 结果：" + tmp4);
}
}
按位或(|)：两个变量其中有一个为 true 时，结果就为 true；只有两个变量均为 false 时结果才为 false。
@SpringBootTest
public class OperationTest {
public static void or() {
boolean tmp = true | false;
System.out.println("true | false 结果：" + tmp);
boolean tmp1 = true | true;
System.out.println("true | true 结果：" + tmp1);
boolean tmp2 = false | true;
System.out.println("false | true 结果：" + tmp2);
boolean tmp3 = false | false;
System.out.println("false | false 结果：" + tmp3);
// 1D = 01B（十进制数 1 的二进制是 01）, 2D = 10B
// 故，01B | 10B = 11B = 3D
int tmp4 = 1 | 2;
System.out.println("1 | 2 结果：" + tmp4);
}
}
同或运算、异或运算、取反运算
-
同或：两个变量相同时，结果为 true；两个变量不相同时，结果为 false。-
获取相同的部分。
-
同或 = 异或 ^ 1。
-
// 1D = 01B（十进制数 1 的二进制是 01）, 2D = 10B
// 故，01B ^ 10B = 11B = 3D
int tmp1 = 1 ^ 2 = 3;
3 ^ 1 = 1
故，1 同或 2 = 1
-
异或(^)：两个变量相同时，结果为 false；两个变量不相同时，结果为 true。- 获取不相同的部分。
@SpringBootTest
public class OperationTest {
public static void xOr() {
// 1D = 01B（十进制数 1 的二进制是 01）, 2D = 10B
// 故，01B ^ 10B = 11B = 3D
int tmp1 = 1 ^ 2;
System.out.println("1 ^ 2 结果：" + tmp1);
int tmp2 = 1 ^ 1;
System.out.println("1 ^ 1 结果：" + tmp2);
boolean tmp3 = true ^ false;
System.out.println("true ^ false 结果：" + tmp3);
}
}
-
逐位取反(~)：将一个数值转换成二进制后，逐位将原数值中 0 变 1、1 变 0。- 注意：
正数的 二进制 最高位必须要是 0、负数的 二进制 最高位必须要是 1。
- 注意：
@SpringBootTest
public class OperationTest {
public static void negate() {
// 1D = 01B = 10B = -2D
int tmp = ~1;
System.out.println("~1：" + tmp);
// -1D = 11B = 00B = 0D
int tmp1 = ~-1;
System.out.println("~1：" + tmp1);
// 3D = 011B = 100B = 4D
int tmp2 = ~3;
System.out.println("~1：" + tmp2);
}
}
短路与、短路或、按位非运算
-
短路与(&&)：-
左边变量为 false 时，不再进行后续比较，结果直接为 false；
-
而，只有两个变量均为 true 时结果才为 true；否则，结果为 false。
-
@SpringBootTest
public class OperationTest {
public static void doubleAnd() {
System.out.println("true && true：" + (true && true));
System.out.println("true && false：" + (true && false));
System.out.println("false && true：" + (false && true));
System.out.println("false && false：" + (false && false));
}
}
-
短路或(||)：-
左边变量为 true 时，不再进行后续比较，结果直接为 true；
-
而，只有两个变量均为 false 时结果才为 false；否则，结果为 true。
-
@SpringBootTest
public class OperationTest {
public static void doubleOr() {
System.out.println("true || true：" + (true || true));
System.out.println("true || false：" + (true || false));
System.out.println("false || true：" + (false || true));
System.out.println("false || false：" + (false || false));
}
}
按位非(!)：取 变量 的反值。
@SpringBootTest
public class OperationTest {
public static void wrong() {
boolean tmp = !false;
System.out.println("!false：" + tmp);
boolean tmp1 = !true;
System.out.println("!true：" + tmp1);
}
}
条件运算
-
条件运算：当条件为 true 时，返回预期结果1；当条件为 false 时，返回预期结果2。 -
这是一个三元运算符。
-
语法结构：
result(结果) = expression(条件) ? statement1(预期结果1) : statement2(预期结果2)。-
条件 expression：可以是表达式，结果必须是
布尔类型. -
预期结果 statement：可以是表达式，但必须与
结果的类型一致。
-
@SpringBootTest
public class OperationTest {
public static void condition() {
for (int i = 0; i < 5; i++) {
int tmp = (i % 2 == 0) ? 1 : 0;
System.out.print(tmp + " ");
}
System.out.println();
}
}
位移运算
位移运算：数度最快，是做二进制运算
，就是将数值转换成 二进制，保证数点的位置不变，然后移动数值整体，同时保证 数值的 二进制 位数不变。
左移、右移
-
不改变数值的符号。
-
移动的位数取值：要大于等于 0。
-
左移(<<)：小数点不动，将数字整体左移。-
高位丢失，低位增加。
-
低位补零。
-
例如：8D = 1000B(省略高位 0) = 0000_0000_0000_0000_0000_0000_0000_1000B
-
左移 一位 时：16D = 0000_0000_0000_0000_0000_0000_0001_0000B = 8D << 1
-
-
左移(<<)：数值变大，当数值大于当前类型所能表示的范围时，数据有效位丢失，数值归零。
@SpringBootTest
public class OperationTest {
public static void moveLeft() {
// 左移 一位
int tmp = 8 << 1;
System.out.println("数值 8 左移 一位：" + tmp + "，二进制结果：" + Integer.toBinaryString(tmp));
// 左移 两位
int tmp1 = 8 << 2;
System.out.println("数值 8 左移 两位：" + tmp1 + "，二进制结果：" + Integer.toBinaryString(tmp1));
// 左移 一位
int tmp3 = -8 << 1;
System.out.println("数值 -8 左移 一位：" + tmp3 + "，二进制结果：" + Integer.toBinaryString(tmp3));
// 左移 两位
int tmp4 = -8 << 2;
System.out.println("数值 -8 左移 两位：" + tmp4 + "，二进制结果：" + Integer.toBinaryString(tmp4));
// 左移 零位
int tmp5 = 8 << 0;
System.out.println("数值 8 左移 零位：" + tmp5 + "，二进制结果：" + Integer.toBinaryString(tmp5));
// 左移 二十八位
int tmp6 = 8 << 28;
System.out.println("数值 8 左移 二十八位：" + tmp6 + "，二进制结果：" + Integer.toBinaryString(tmp6));
// 左移 二十九位
int tmp7 = 8 << 29;
System.out.println("数值 8 左移 二十九位：" + tmp7 + "，二进制结果：" + Integer.toBinaryString(tmp7));
}
}
-
右移(>>)：小数点不动，将数字整体右移。-
高位增加，低位丢失。
-
数字是正数时，高位补 0，数字是复数时，高位补 1。
-
例如：8D = 1000B(省略高位 0) = 0000_0000_0000_0000_0000_0000_0000_1000B
- 右移 一位 时：4D = 100B = 0000_0000_0000_0000_0000_0000_0000_0100B = 8D >> 1
-
例如：-8D = 1111_1111_1111_1111_1111_1111_1111_1000B
-
右移 一位 时：-4D = 1111_1111_1111_1111_1111_1111_1111_1100B = -8D >> 1
-
右移 两位 时：-2D = 1111_1111_1111_1111_1111_1111_1111_1110B = -8D >> 2
-
右移 三位 时：-1D = 1111_1111_1111_1111_1111_1111_1111_1111B = -8D >> 3
-
右移 四位 时：-1D = 1111_1111_1111_1111_1111_1111_1111_1111B = -8D >> 4
-
-
-
右移(>>)：数值变小，数据有效位慢慢被补充的位数取代，正数归 0，负数归 -1。
@SpringBootTest
public class OperationTest {
public static void moveRight() {
// 右移 一位
int tmp = 8 >> 1;
System.out.println("数值 8 右移 一位：" + tmp + "，二进制结果：" + Integer.toBinaryString(tmp));
// 右移 两位
int tmp1 = 8 >> 2;
System.out.println("数值 8 右移 两位：" + tmp1 + "，二进制结果：" + Integer.toBinaryString(tmp1));
// 右移 三位
int tmp2 = 8 >> 3;
System.out.println("数值 8 右移 三位：" + tmp2 + "，二进制结果：" + Integer.toBinaryString(tmp2));
// 右移 四位
int tmp9 = 8 >> 4;
System.out.println("数值 8 右移 四位：" + tmp9 + "，二进制结果：" + Integer.toBinaryString(tmp9));
// 右移 五位
int tmp10 = 8 >> 5;
System.out.println("数值 8 右移 五位：" + tmp10 + "，二进制结果：" + Integer.toBinaryString(tmp10));
// 右移 零位
int tmp5 = 8 >> 0;
System.out.println("数值 8 右移 零位：" + tmp5 + "，二进制结果：" + Integer.toBinaryString(tmp5));
// 右移 一位
int tmp3 = -8 >> 1;
System.out.println("数值 -8 右移 一位：" + tmp3 + "，二进制结果：" + Integer.toBinaryString(tmp3));
// 右移 两位
int tmp4 = -8 >> 2;
System.out.println("数值 -8 右移 两位：" + tmp4 + "，二进制结果：" + Integer.toBinaryString(tmp4));
// 右移 三位
int tmp6 = -8 >> 3;
System.out.println("数值 -8 右移 三位：" + tmp6 + "，二进制结果：" + Integer.toBinaryString(tmp6));
// 右移 四位
int tmp7 = -8 >> 4;
System.out.println("数值 -8 右移 四位：" + tmp7 + "，二进制结果：" + Integer.toBinaryString(tmp7));
// 右移 五位
int tmp8 = -8 >> 5;
System.out.println("数值 -8 右移 五位：" + tmp8 + "，二进制结果：" + Integer.toBinaryString(tmp8));
}
}
无符号右移
-
无符号右移(>>>)：小数点不动，将数字整体右移。-
高位增加，低位丢失。
-
无论数字是正数还是复数，高位统一补 0。
-
正数使用 >>> 时，与使用 >> 一样的效果。
-
@SpringBootTest
public class OperationTest {
public static void unsignedMoveRight() {
// 无符号右移 一位
int tmp = 8 >>> 1;
System.out.println("数值 8 无符号右移 一位：" + tmp + "，二进制结果：" + Integer.toBinaryString(tmp));
// 无符号右移 两位
int tmp1 = 8 >>> 2;
System.out.println("数值 8 无符号右移 两位：" + tmp1 + "，二进制结果：" + Integer.toBinaryString(tmp1));
// 无符号右移 三位
int tmp2 = 8 >>> 3;
System.out.println("数值 8 无符号右移 三位：" + tmp2 + "，二进制结果：" + Integer.toBinaryString(tmp2));
// 无符号右移 四位
int tmp3 = 8 >>> 4;
System.out.println("数值 8 无符号右移 四位：" + tmp3 + "，二进制结果：" + Integer.toBinaryString(tmp3));
// 无符号右移 五位
int tmp4 = 8 >>> 5;
System.out.println("数值 8 无符号右移 四位：" + tmp4 + "，二进制结果：" + Integer.toBinaryString(tmp4));
System.out.println("8 的二进制：" + Integer.toBinaryString(8));
System.out.println("-8 的二进制：" + Integer.toBinaryString(-8));
// 无符号右移 一位
int tmp5 = -8 >>> 1;
System.out.println("数值 -8 无符号右移 一位：" + tmp5 + "，二进制结果：" + Integer.toBinaryString(tmp5));
// 无符号右移 两位
int tmp6 = -8 >>> 2;
System.out.println("数值 -8 无符号右移 两位：" + tmp6 + "，二进制结果：" + Integer.toBinaryString(tmp6));
// 无符号右移 三位
int tmp7 = -8 >>> 3;
System.out.println("数值 -8 无符号右移 三位：" + tmp7 + "，二进制结果：" + Integer.toBinaryString(tmp7));
// 无符号右移 四位
int tmp8 = -8 >>> 4;
System.out.println("数值 -8 无符号右移 四位：" + tmp8 + "，二进制结果：" + Integer.toBinaryString(tmp8));
// 无符号右移 五位
int tmp9 = -8 >>> 5;
System.out.println("数值 -8 无符号右移 四位：" + tmp9 + "，二进制结果：" + Integer.toBinaryString(tmp9));
}
}
总结
-
=(等号)是赋值运算符。 -
三元运算符：是指这种 运算符需要三个变量才能书写。- 只有
? :这一个三目运算符。
- 只有
-
双元运算符：是指这种 运算符需要两个变量才能书写。 -
单元运算符：是指这种 运算符只需要一个变量才能书写。-
有
按位非运算符(!)。 -
有
取反运算符(~)。 -
有
自增运算符(++)。 -
有
自减运算符(--)。 -
有
正号(+)。 -
有
负号(-)。
-
-
算术运算基本上是用于数值间运算。 -
逻辑运算之取反运算(~)不能用于布尔类型，只能用于数值运算。 -
逻辑运算之按位非运算(!)不能用于数值运算，只能用于布尔类型。 -
逻辑运算中条件运算符(? :)。 -
逻辑运算中逻辑运算符(&&)、(||)、(!)。 -
逻辑运算中位运算符(&)、(|)、(^)、(~)、(<<)、(>>)、(>>>)。
复合赋值运算符
算术运算
-
a = a + b 等价于 a += b。
-
a = a - b 等价于 a -= b。
-
a = a * b 等价于 a /*= b。
-
a = a / b 等价于 a /= b。
-
a = a % b 等价于 a %= b。
逻辑运算
-
a = a << b 等价于 a <<= b。
-
a = a >> b 等价于 a >>= b。
-
a = a & b 等价于 a &= b。
-
a = a | b 等价于 a |= b。
-
a = a ^ b 等价于 a ^= b。
-
a = a % b 等价于 a %= b。
运算符的优先级
-
第一级：
括号运算符，及其内表达式会被识别成一个整体，其值 = 表达式的结果，有小括号 ()、中括号 []、大括号 {}。 -
第二级：
一元运算符，有 非(!)、正号(+)、负号(-)、取反(~)、自增(++)、自减(–)。 -
第三级：
算术运算符之乘除运算，有 乘(*)、除(/)、模(%)。 -
第四级：
算术运算符之加减运算，有 加(+)、减(-)。 -
第五级：
位移运算符，有 左移(<<)、右移(>>)、无符号右移(>>>)。 -
第六级：
关系运算符之大小运算，有 小于(<)、小于等于(<=)、大于(>)、大于等于(>=)。 -
第七级：
关系运算符之等于运算，有 类型比较(instanceof)、等于(==)、不等于(!=)。 -
第八级：
位运算符之按位与运算，有 与(&)。 -
第九级：
位运算符之按位异或运算，有 异或(^)。 -
第十级：
位运算符之按位或运算，有 或(|)。 -
第十一级：
逻辑运算符之短路与运算，有 短路与(&&)。 -
第十二级：
逻辑运算符之短路或运算，有 短路或(||)。 -
第十三级：
三元运算符（条件运算符），有 条件运算符(? 。 -
第十四级：
赋值运算符，有 赋值号(=)。 -
第十五级：
复合赋值运算符，有 加等(+=)、减等(-=)、乘等(*=)、除等(/=)、模等(%=)、与等(&=)、或等(|=)、异或等(^=)
、取反等(~=)、左移等(<<=)、右移等(>>=)、无符号右移等(>>>=)。 -
同级别的运算符的优先级是一样的。