运算分类及运算符优先级（Java 版）

十⑧

已于 2023-02-09 20:39:33 修改

阅读量1.2k

点赞数

分类专栏：通用的知识 Java 学习笔记文章标签： java 运算符运算符优先级位移运算逻辑运算

于 2023-02-08 00:09:05 首次发布

本文链接：https://blog.csdn.net/weixin_46766584/article/details/128928075

版权

Java 学习笔记同时被 2 个专栏收录

28 篇文章

订阅专栏

通用的知识

20 篇文章

订阅专栏

本文详细介绍了Java中的各种运算符，包括算术运算（加、减、乘、除、模）、关系运算（大于、小于、等于、不等于、大于等于、小于等于）、逻辑运算（与、或、异或、取反）以及位运算（左移、右移、无符号右移）。还讨论了自增、自减、类型比较instanceof和运算符的优先级。

摘要由CSDN通过智能技术生成

运算分类及运算符（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)、等于(==)、不等于(!=)。
第八级：位运算符之按位与运算，有 与(&)。
第九级：位运算符之按位异或运算，有 异或(^)。
第十级：位运算符之按位或运算，有 或(|)。
第十一级：逻辑运算符之短路与运算，有 短路与(&&)。
第十二级：逻辑运算符之短路或运算，有 短路或(||)。
第十三级：三元运算符（条件运算符），有 条件运算符(? 😃。
第十四级：赋值运算符，有 赋值号(=)。
第十五级：复合赋值运算符，有加等(+=)、减等(-=)、乘等(*=)、除等(/=)、模等(%=)、与等(&=)、或等(|=)、异或等(^=)
、取反等(~=)、左移等(<<=)、右移等(>>=)、无符号右移等(>>>=)。
同级别的运算符的优先级是一样的。