java 运算符

debugBiubiubiu2000

已于 2023-05-27 17:44:35 修改

阅读量75

点赞数

分类专栏： java基础文章标签： java 开发语言

于 2023-05-27 15:53:50 首次发布

本文链接：https://blog.csdn.net/2301_77659011/article/details/130885647

版权

java基础专栏收录该内容

40 篇文章 0 订阅

订阅专栏

运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

算术运算符

算术运算符是对数值类型的变量进行运算的

常用的运算符有以下几个：

注意：% 的本质：看一个公式 a % b = a - a / b * b（注意先乘除后加减）；当a和b都是小数或其中一个是小数，会有一个强转，即公式变为 a % b = a - (int)(a / b) * b

public class Test {
    public static void main(String[] args){
        // 除号（/）的使用
        // 10 和 4 两个操作数都是int类型，所以运算结果最高也是int类型，所以只取2.5的整数部分，即2
        System.out.println(10 / 4); // 2
        // 10.0 为double，4位int，整个运算结果为double类型，所以结果为2.5
        System.out.println(10.0 / 4); // 2.5
        double d = 10.0 / 4;
        System.out.println(d); // 2.5

        // 10 和 4 两个操作数都是int类型，所以运算结果最高也是int类型，所以只取2.5的整数部分，即2
        // 赋值给double类型后，将2转换为double类型，变为2.0
        double d1 = 10 / 4;
        System.out.println(d1); // 2.0

        // 针对以下两个式子，有个疑问：
        // 为什么都是除得尽的情况，10.1 / 5 得到的是2.02这个刚好除得尽的结果，而8.1 / 3得到的却是一个近似值
        System.out.println(10.1 / 5); // 2.02
        double d2 = 8.1 / 3;
        System.out.println(d2); // 2.6999999999999997


        // 取余（%）
        // % 的本质：看一个公式 a % b = a - a / b * b（注意先乘除后加减）
        // 10 % 3 = 10 - 10 / 3 * 3 = 10 - 3 * 3 = 10 - 9 = 1 (注意！！在Java中 10 / 3 = 3，不是除不尽)
        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
        // -10 - (-10) / (-3) * (-3) = -10 - 3 * (-3) = -10 - (-9) = -1
        System.out.println(-10 % -3); // -1


        // 自增的两个经典面试题，自减和自增同理
        // 第一题
        int i = 1;
        // 以下运算是先赋值在自增
        // 计算机内部会使用一个临时变量存储结果：（1）temp = i;(i初始为1) (2)i = i + 1; (3)i = temp;
        // 相当于 j = i++; (1)temp = i;(i初始为1) (2)i = i + 1; (3)j = temp;
        i = i++;
        System.out.println(i); // 1

        // 第二题
        int i1 = 1;
        // 以下结果是先自增再赋值
        // (1)i1 = i1 + 1; (2)temp = i1; (3)i1 = temp;
        // 相当于 j = ++i1; => (1)i1 = i1 + 1; (2)temp = i1; (3)j = temp;
        i1 = ++i1;
        System.out.println(i1); // 2

    }
}

关系运算符（比较运算符）

关系运算符的结果都是boolean型，要么是true，要么是false
关系表达式经常用在if结构的条件中或者循环结构的条件中
关系运算符组成的表达式，成为关系表达式

逻辑运算符

短路与 &&，短路或 ||，取反！
逻辑与 &，逻辑或 |，逻辑异或 ^
短路与和逻辑与的区别：当第一个条件为假时，短路与不会对第二个条件进行判断，而逻辑与则是不管第一个条件是真是假，都会对第二个条件进行判断
同理，短路或是当第一个条件为真时，不会对第二个条件进行判断，而逻辑或是不管第一个条件是真是假，都会对第二个条件进行判断
异或：只有两个条件不一样时为真

如下表所示：

赋值运算符

基本赋值运算符：=
复合赋值运算符：+=、-=、/=、*=、%=

赋值运算符的特点：

运算顺序从右往左，int num = a + b; 先计算a + b，再把结果赋值给num
赋值运算符的左边只能是变量，右边可以是常量、变量、表达式
复合赋值运算符等价于以下效果：a += 3 <=> a = a + 3

复合赋值运算符会进行类型转换

public class Test {
    public static void main(String[] args){
        // 复合赋值运算符会进行类型转换
        byte b = 1;
        // 以下式子按道理来说等价于 b = b + 3;
        // b 是byte类型，3 是int类型，运算结果为int类型，再赋值给byte类型的变量b，理论上会报错
        // 但是底层会进行类型转换，所以不会报错，自增和自减同理，也会进行类型转换
        // 但如果直接写成：b = b + 3; 这样就会报错，因为这样子写不会进行类型转换，所以会报不能把int类型赋值给byte类型的错误
        b += 3; // 这样写等价于 b = (byte)(b + 3);
    }
}

三元运算符

基本语法：条件表达式？表达式1 ：表达式2，条件表达式为true，返回表达式1的运算结果，否则返回表达式2的运算结果

运算符优先级

下表的优先级从上往下依次降低

位运算符

java中有7个位运算符：

& 按位与：两位全为1，结果为1，否则为0
| 按位或：两位有一位为1，结果为1，否则为0
^ 按位异或：两位一个为0，一个为1，结果为1，否则为0

~ 按位取反：0变为1, 1变为0

public class Test {
    public static void main(String[] args){
        // 推导
        // 计算机中的所有运算都是以补码的形式进行计算，结果是以原码形式输出
        // 1、求 2 的补码，先要求出 2 的原码，再求 2 的反码，最后求 2 的补码
        // 2 是int类型，占四个字节，2 的原码 00000000 00000000 00000000 00000010
        // 由于 2 是正数，所以三码合一
        // 2 的补码为       00000000 00000000 00000000 00000010
        // 同理，3 的补码为  00000000 00000000 00000000 00000011
        // 按位与的结果为    00000000 00000000 00000000 00000010 （该结果为补码）
        // 因为上述补码运算结果为正数（符号位为0），三码合一
        // 所以上述补码的的原码为 00000000 00000000 00000000 00000010
        // 转为十进制，推导出的输出结果为2
        System.out.println(2 & 3); // 2

        // 求 -2 的补码，先要求出 -2 的原码，再求 -2 的反码，最后求 -2 的补码
        // 负数的原码求补码可用一个技巧：从右边数第一个1及其右边保持不变，左边按位取反（符号位不取反）
        // -2 是int类型，占四个字节，-2 的原码 10000000 00000000 00000000 00000010
        // -2 的补码为         11111111 11111111 11111111 11111110
        // ~-2操作：按位取反    00000000 00000000 00000000 00000001  （该结果为补码）
        // 将上述结果为正数，三码合一，所以转变为原码为 00000000 00000000 00000000 00000001
        // 转为十进制，推导出的输出结果为1
        System.out.println(~-2); // 1

        // 2 是int类型，占四个字节，2 的原码 00000000 00000000 00000000 00000010
        // 三码合一，2 的补码为  00000000 00000000 00000000 00000010
        // ~2操作：按位取反      11111111 11111111 11111111 11111101  （该结果为补码）
        // 将上述结果为负数，所以转变为原码为 10000000 00000000 00000000 00000011
        // 转为十进制，推导出的输出结果为-3
        System.out.println(~2); // -3

        // 按位或、按位异或同理
        // 2 的原码   00000000 00000000 00000000 00000010
        // 3 的原码   00000000 00000000 00000000 00000011
        // 三码合一
        // 2 的补码   00000000 00000000 00000000 00000010
        // 3 的补码   00000000 00000000 00000000 00000011
        // 2 ^ 3结果  00000000 00000000 00000000 00000001  （运算结果为补码）
        // 补码为正数，所以原码也为 00000000 00000000 00000000 00000001
        // 对应的十进制为 1
        System.out.println(2 ^ 3); // 1
    }
}

>> 算术右移：低位溢出，符号位不变，并用符号位补溢出的高位
<< 算术左移：符号位不变，低位补0
>>> 逻辑右移，也叫无符号右移：低位溢出，高位补0

没有 <<< 符号的

public class Test {
    public static void main(String[] args){
        // 1 右移 2 位，本质是 1 / 2 / 2 = 0
        // 1 的补码：00000000 00000000 00000000 00000001
        // 右移两位，低位溢出，符号位不变，用符号位补溢出的高位
        // 所以结果为 00000000 00000000 00000000 000000 00（符号位补溢出的位置） 01（溢出，直接丢弃）
        // 上述补码结果还是正数，所以源码也为00000000 00000000 00000000 00000000
        // 结果为0
        System.out.println(1 >> 2); // 0

        // 1 左移 2 位，本质是 1 * 2 * 2 = 4
        // 1 的补码：00000000 00000000 00000000 00000001
        // 左移两位，不溢出的情况下符号位不变，低位补0
        // 所以结果为 00000000 00000000 00000000 00000001 00（低位补0）
        // 上述补码结果还是正数，所以源码也为00000000 00000000 00000000 00000001 00
        // 结果为4
        System.out.println(1 << 2); // 4

        // 低位溢出，高位补0
        // 2 的补码  00000000 00000000 00000000 00000010
        // 逻辑右移 3 位 000(高位补0) 00000000 00000000 00000000 00000 010(丢弃)
        System.out.println(2 >>> 3); // 0
    }
}