Java运算符，一文带你彻底拿捏~

要一杯卡布奇诺

已于 2023-08-10 08:28:54 修改

阅读量343

点赞数 8

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

于 2023-08-09 22:40:46 首次发布

本文链接：https://blog.csdn.net/qq_63200557/article/details/132198142

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

——Java中运算符是一种特殊的符号，用来进行数据的运算、赋值和比较等

思维导图

一.算术运算符

1.什么是算术运算符
——算术运算符是用于数据类型值之间，使用2个或以上的数据进行运算

2.算术运算符概括

算术运算符	解释	示例
+，-	正号，负号	+10，-10
+,-	加，减	10 + 10，11 - 10
*，/	乘，除	12 * 3，12 / 3
%	取模（取余）	3 % 4
++	前置++：先自增，后取值后置++：先取值，后自增	a = 3; b = ++a; a = 3; c = a++;
--	前置--：先自减，后取值后置--：先取值，后自减	a = 3; b = --a; a = 3; c = a--;
+	字符串相加	"str" + "hello""strhello"

3.一个小case快速了解算术运算符

public class Test {
    public static void main(String[] args) {
        //+,-：正负号
        int num1 = +10;
        int num2 = -10;
        System.out.println(num1);//10
        System.out.println(num2);//-10

        //+,-：加减法
        int num3 = 10 + 5;
        int num4 = 15 - 10;
        System.out.println(num3);//15
        System.out.println(num4);//5

        //*,/：乘除法
        int num5 = 12 * 5;
        int num6 = 14 / 4;
        System.out.println(num5);//60
        System.out.println(num6);//3

        //%：取余
        int n = 14 % 5;
        System.out.println(n);//4

        //++:自增运算符
        int a = 10;
        int data1 = a++;//后置++：先取值，后自增
        System.out.println(a);//11
        System.out.println(data1);//10
        a = 10;
        int data2 = ++a;//前置++：先自增，后取值
        System.out.println(a);//11
        System.out.println(data2);//11

        //--：自减运算符
        int b = 10;
        int ele1 = b--;
        System.out.println(b);//9
        System.out.println(ele1);//10
        b = 10;
        int ele2 = --b;
        System.out.println(b);//9
        System.out.println(ele2);//9

        //+：字符串相加
        String str1 = "我爱你";
        String str2 = "中国";
        System.out.println(str1 + str2);//我爱你中国
    }
}

4.算术运算符的细节讨论

1）除(/)：整数相除时，得到的是一个整数，若是有小数部分，则舍去小数部分，保留整数部分[向下取整]

public class Test {
    public static void main(String[] args) {
        //除(/)：整数相除时，得到的是一个整数，若是有小数部分，则舍去小数部分，保留整数部分
        int a = 10;
        int b = 4;
        int c = a / b;//10 / 4 = 2.5,舍去小数0.5，留下2
        System.out.println(c);//2

        double num1 = 10.0;
        double num2 = 3;
        double num = num1 / num2;//浮点数之间的相除则需要保留小数部分
        System.out.println(num);//3.3333333333333335
    }
}

2）进行取模运算时，a % b = a - （a / b） * b（对于正负数均适用）

public class Test {
    public static void main(String[] args) {
        //进行取模运算时，a % b = a - (a / b) * b（对于正负数均适用）
        //整数的取模运算
        int num1 = -10 % 3;//-10 % 3 = -10 - (-10 / 3) * 3 = -1
        System.out.println(num1);//-1
        int num2 = 10 % 3;//10 % 3 = 10 - 10 / 3 * 3 = 1
        System.out.println(num2);//1
        int num3 = -10 % -3;//-10 % -3 = -10 - (-10 / -3) * (-3) = -1
        System.out.println(num3);//-1
        int num4 = 10 % -3;//10 % -3 = 10 - (10 / (-3)) * (-3) = 1
        System.out.println(num4);//1

        //浮点数的取模运算
        double data1 = 10.3 % 3;//10.3 % 3 = 10.3 - 10.3 / 3 * 3 = 1.3
        System.out.println(data1);//1.3000000000000007
        double data2 = -10.3 % 3;//-10.3 % 3 = -10.3 - (-10.3 / 3) * 3 = -1.3
        System.out.println(data2);//-1.3000000000000007
    }
}

5.思考以下代码输出

public class Test {
    public static void main(String[] args) {
        int i = 10;
        i = i++;
        System.out.println(i);//10
        
        //为什么是10？
        //也按照前置后置++的规则进行运算
    }
}

二.赋值运算符

1.什么是赋值运算符
—— 赋值运算符用于将某个数据值赋给相对应的数据类型变量

2.赋值运算符的分类

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

3.一个小case快速了解赋值运算符

public class Test {
    public static void main(String[] args) {
        //基本赋值运算符：=
        int num = 10;//把10赋值给了int类型的变量num
        System.out.println(num);//10

        //复合赋值运算符：+=、-=、*=、/=、%=等
        int data = 10;
        data += 10;//data = data + 10;
        data -= 5;//data = data - 5
        data *= 4;//data = data * 4
        data /= 3;//data = data / 3;
        data %= 5;//data = data % 5;
    }
}

4.赋值运算符的细节讨论

1）运算顺序从右往左
2）赋值运算符的左边，必须为变量；赋值运算符的右边，可以为变量、表达式、常量值

public class Test {
    public static void main(String[] args) {
        //运算顺序从右往左
        int data = 30;//把右边的30赋给左边的int类型变量data
        System.out.println(data);//30

        //赋值运算符的左边，必须为变量；赋值运算符的右边，可以为变量、表达式、常量值
        int num1 = data;//左边为变量
        int num2 = data++;//左边为表达式
        int num3 = 20;//左边为常量值
        System.out.println(num1);//30
        System.out.println(num2);//30
        System.out.println(num3);//20
    }
}

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

public class Test {
    public static void main(String[] args) {
        //复合赋值运算符会进行类型转换
        byte b = 10;
        int a = 10;
        b += a;//b = (byte)(b + a):会自动把int类型的a转化为byte类型
        System.out.println(b);//20

        char ch = 12;
        int num = 86;
        ch += num;//ch = (char)(ch + num):会自动把int类型的num转化为char类型
        System.out.println(ch);//b

        double data = 13.14;
        int ele = 10;
        ele += data;//ele =(int) (ele + data):会自动把double类型的data转化为int类型
        System.out.println(ele);//23
    }
}

三.关系运算符

1.什么是关系运算符

—— 关系运算符常用于表示某个条件的真假，所以关系运算符的结果都是boolean类型，关系运算符常用在if结构的条件判断和循环的条件判断中

2.关系运算符概览

关系运算符	解释	示例
==	判断相等	10 == 7
!=	不等于	10 != 7
<	小于	10 < 12
>	大于	12 > 13
<=	小于等于	13 <= 15
>=	大于等于	15 >= 16
instanceof	检查对象是否为该类的运行类型	"china" instanceof String

3.一个小case快速了解关系运算符

public class Test {
    public static void main(String[] args) {
        //关系运算符
        System.out.println(3 == 5);//false
        System.out.println(3 != 5);//true
        System.out.println(3 > 5);//false
        System.out.println(10 < 12);//true
        System.out.println(12 >= 12);//true
        System.out.println(15 <= 13);//false

        String str = "love";
        System.out.println(str instanceof Object);//true：String是Object的子类
    }
}

4.关系运算符的细节讨论

1）关系运算符的结果都是boolean类型，只有true和false两种结果
2）注意：不要把判断相等'"=="写错成了赋值"="

public class Test {
    public static void main(String[] args) {
        //关系运算符的结果都是boolean类型，只有true和false两种结果
        System.out.println(3 < 5);//true
        System.out.println(3 > 5);//false

        //注意：不要把判断相等'"=="写错成了赋值"="
        int num = 10;
        System.out.println(num = 10);//10：这里的num = 10是赋值，任何输出
        System.out.println(num == 10);//true：这里的num == 10是判断相等
    }
}

四.逻辑运算符

1.什么是逻辑运算符

—— 逻辑运算符用于连接多个条件或多个关系表达式，最后得到一个是boolean类型的结果，也就是说，逻辑运算符只有两种结果：true , false

2.逻辑运算符概览

逻辑运算符	解释	示例
&&	短路与：全真为真，一假则假	a = true; b = false; a && b
\|\|	短路或：一真则真，全假则假	a = true;b = false; a \|\| b
&	逻辑与：全真为真，一假则假	a = true; b = false; a & b
\|	逻辑或：一真则真，全假则假	a = true;b = false; a \| b
^	逻辑异或：一真一假则为真，全真全假则为假	a = true;b = false; a ^ b
!	真变假，假变真	a = false; !a

3.一个小case快速了解逻辑运算符

public class Test {
    public static void main(String[] args) {
        //逻辑运算符
        boolean b1 = true;
        boolean b2 = false;

        //&&(短路与)：全真为真，一假则假
        System.out.println(b1 && b2);//false
        //||(短路或)：一真为真，全假为假
        System.out.println(b1 || b2);//true
        //&(逻辑与)：全真为真，一假则假
        System.out.println(b1 & b2);//false
        //|(逻辑或)：一真为真，全假为假
        System.out.println(b1 | b2);//true
        //^(逻辑异或)：一真一假则为真，全真全假则为假
        System.out.println(b1 ^ b2);//true
        //！(逻辑取反）：真变假，假变真
        System.out.println(!b1);//false
        System.out.println(!b2);//true
    }
}

4.逻辑运算符的细节讨论

1）&& 与 & 的判断过程
&&：在判断过程中，如果第一个条件为false，则不会在判断后面的条件，最终的结果为false
&：在判断过程中，不管第一个条件是否为false，依旧会判断第二个条件

public class Test {
    public static void main(String[] args) {
        int a = 0;
        int b = 10;

        //&&：在判断过程中，如果第一个条件为false，则不会在判断后面的条件，最终的结果为false
        if (a > 1 && b++ < 15) {
            System.out.println("hehe");
        }
        System.out.println(a);//0
        System.out.println(b);//10:b++ < 15没有执行

        //&：在判断过程中，不管第一个条件是否为false，依旧会判断第二个条件
        if (a > 1 & b++ < 15) {
            System.out.println("haha");
        }
        System.out.println(a);//0
        System.out.println(b);//11:b++ < 15执行了
    }
}

2）|| 与 | 的判断过程

||：在判断过程中，如果第一个条件为true，则不会在判断后面的条件，最终的结果为true
|：在判断过程中，不管第一个条件是否为true，依旧会判断第二个条件

public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 12;

        //||：在判断过程中，如果第一个条件为true，则不会在判断后面的条件，最终的结果为true
        if (num1 > 1 || num2++ < 15) {
            System.out.println("hehe");//hehe
        }

        //|：在判断过程中，不管第一个条件是否为true，依旧会判断第二个条件
        System.out.println(num1);//10
        System.out.println(num2);//12:num2++ < 15没有执行

        if (num1 > 1 | num2++ < 15) {
            System.out.println("haha");//haha        
        }
        System.out.println(num1);//10
        System.out.println(num2);//13:num2++ < 15执行了
    }
}

五.三元运算符

1.什么是三元运算符
——三元运算符其实就是有三个操作数的运算符

三元运算符格式：条件表达式？表达式1 ：表达式2
解释：如果条件表达式为真，则执行表达式1，否则，执行表达式2

2.一个小case快速了解三元运算符

public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 12;

        //三元运算符
        int res1 = 10 > 5 ? 10 : 5;
        int res2 = num1 > num2 ? num1 : num2;
        System.out.println(res1);//10
        System.out.println(res2);//12
    }
}

3.三元运算符的细节讨论

1）表达式1和表达式2要为可以赋给接收变量的类型（或可以自动类型转化）

public class Test {
    public static void main(String[] args) {
        //表达式1和表达式2要为可以赋给接收变量的类型（或可以自动类型转化）
        int num1 = 10.1 > 5.1 ? (int) 10.1 : (int) 5.1;//需要把double类型转化成int类型

        int data1 = 100;
        int data2 = 97;
        char ch = data1 > data2 ? (char) data1 : (char) data2;//把int类型转化成char类型

        System.out.println(num1);//10
        System.out.println(ch);//d
    }
}

2）三元运算符可以转成if - else语句

public class Test {
    public static void main(String[] args) {
        //三元运算符可以转成if - else语句
        int num1 = 100;
        int num2 = 110;
        int res1 = num1 > num2 ? num1 : num2;
        System.out.println(res1);/110

        int res2 = 10;
        //转化成if-else语句
        if (num1 > num2)
            res2 = num1;
        else
            res2 = num2;
        System.out.println(res2);//110
    }
}

六.位运算

6.1 进制

1.什么是进制
—— 进制就是几进制数，我们日常生活使用的十进制，但是还有其他几种常用的进制

二进制：满2进1，只有0和1，以0b或0B开头
八进制：满8进1，以数字0开头
十六进制：满16进1，有0-9，A(a)-F(f),A是10，F是15，以0x或0X开头

2.一个小case快速了解进制

public class Test {
    public static void main(String[] args) {
        //进制
        //二进制：以0b/0B开头
        int num1 = 0b01110;
        //八进制：以0开头
        int num2 = 0123;
        //十六进制：以0x/0X开头
        int num3 = 0xabd2;

        //输出:输出的时候是转化为十进制输出的
        System.out.println(num1);//14
        System.out.println(num2);//83
        System.out.println(num3);//43986
    }
}

3.某进制转换成十进制

1）二进制转十进制
转换规则：从低位开始，将每个位上的数提取出来，乘上2 ^ (第几位 - 1）的次方，最后求和
2）八进制转十进制
转换规则：从低位开始，将每个位上的数提取出来，乘上8 ^ (第几位 - 1）的次方，最后求和
3）十六进制转十进制
转换规则：从低位开始，将每个位上的数提取出来，乘上16 ^ (第几位 - 1）的次方，最后求和

public class Test {
    public static void main(String[] args) {
        //二进制转十进制
        int num1 = 0b111011;
        //1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 + 1*2^4 + 1*2^5= 59
        System.out.println(num1);//59

        //八进制转十进制
        int num2 = 01234;
        //4*8^0 + 3*8^1 + 2*8^2 + 1*8^3 = 668
        System.out.println(num2);//668

        //十六进制转十进制
        int num3 = 0xab78;
        //8*16^0 + 7*16^1 + b(11)*16^2 + a(10)*16^3 = 8 + 102 + 2816 + 40960
        System.out.println(num3);//43896
    }
}

4.十进制转换成某进制

1）十进制转二进制
转换规则：把十进制数不断除2，知道商为0为止，然后将每步的余数倒过来，就是相对应的二进制
2）十进制转八进制
转换规则：把十进制数不断除8，知道商为0为止，然后将每步的余数倒过来，就是相对应的二进制
3）十进制转十六进制
转换规则：把十进制数不断除16，知道商为0为止，然后将每步的余数倒过来，就是相对应的二进制

5.二进制转八进制、十六进制

1）二进制转八进制
转换规则：从低位开始，每三个二进制位就是一个八进制位
2）二进制转十六进制
转换规则：从低位开始，每四个二进制位就是一个十六进制位

public class Test {
    public static void main(String[] args) {
        //二进制转八进制:从低位开始，每三个二进制位是一个八进制位
        int data1 = 0b0011110111011;
        //对应的八进制：03673
        int data2 = 03673;
        System.out.println(data1 == data2);//true

        //二进制转十六进制：从低位开始，每四个二进制位是一个十六进制位
        int num1 = 0b1011101010101;
        //对应的十六进制：0x1755
        int num2 = 0x1755;
        System.out.println(num1 == num2);//true
    }
}

6.八进制、十六进制转二进制

1）八进制转二进制
转换规则：从低位开始，每八进制的一位是二进制的三位
2）十六进制转二进制
转换规则：从低位开始，每十六进制的一位是二进制的四位

public class Test {
    public static void main(String[] args) {
        //八进制转二进制
        int num1 = 01234;
        //对应的二进制：1010011100
        int num2 = 0b1010011100;
        System.out.println(num1 == num2);//true

        //十六进制转二进制
        int data1 = 0xab34;
        //对应的二进制：1010101100110100
        int data2 = 0b1010101100110100;
        System.out.println(data1 == data2);//true
    }
}

6.2 位运算

1.什么是位运算
—— 使用二进制位进行运算的操作叫做位运算

2.原码、反码、补码详解

1）二进制的最高符号位：0表示正，1表示负
2）正整数的原码、反码、补码均相同
3）负数的反码 = 原码符号位不变，其他位取反
4）负数的补码 = 负数的反码 + 1 ；负数的反码 = 负数的补码 - 1
5）Java中的数都是有符号的，即Java中没有无符号数
7）计算机再进行运算均是以补码来进行的
8）计算机计算的结果是原码

3.位运算符

位运算符	解释	示例
&(按位与)	全1为1，有0为0	3 & 2
\| (按位或)	有1为1，全0为0	3 \| 2
^ (按位异或)	不同为1，相同为0	3 ^ 21
~ (按位取反)	1变0，0变1	~12
>> (算术右移)	向右移动，低位溢出，高位以符号位补全	2 >> 1
<< (算术左移)	符号位不变，低位补0	2 << 3
>>> (逻辑右移/无符号右移)	低位溢出，高位补0	2 >>> 3

4.一个小case快速了解位运算符

public class Test {
    public static void main(String[] args) {
        int num1 = 9 & 5;
        //  9:1001
        //  5:0101
        //结果:0001 --> 1
        System.out.println(num1);//1

        int num2 = 9 | 5;
        //  9:1001
        //  5:0101
        //结果:1101 --> 13
        System.out.println(num2);//13

        int num3 = 9 ^ 5;
        //  9:1001
        //  5:0101
        //结果:1100 --> 12
        System.out.println(num3);//12

        int num4 = 2 >> 1;
        //   2:0010
        //结果:0001 --> 1
        System.out.println(num4);//1

        int num5 = 2 << 5;
        //   2:0000010
        //结果: 01000000--> 64
        System.out.println(num5);//64

        int num6 = 16 >>> 3;
        //  16:10000
        //结果: 00010--> 2
        System.out.println(num6);//2
    }
}

5.思考下面的代码输出什么

public class Test {
    public static void main(String[] args) {
        int num1 = 1 >> 2;
        //00000000 00000000 00000000 00000001
        //右移两位：
        //00000000 00000000 00000000 00000000：0
        System.out.println(num1);//0

        int num2 = -1 >> 2;
        //10000000 00000000 00000000 00000001 原码
        //11111111 11111111 11111111 11111110 反码
        //11111111 11111111 11111111 11111111 补码
        //右移两位：
        //11111111 11111111 11111111 11111111 补码
        //11111111 11111111 11111111 11111110 反码
        //10000000 00000000 00000000 00000001 原码：-1
        System.out.println(num2);//-1

        int num3 = 1 << 2;
        //00000000 00000000 00000000 00000001
        //左移两位：
        //00000000 00000000 00000000 00000100：4
        System.out.println(num3);//4

        int num4 = -1 << 2;
        //10000000 00000000 00000000 00000001 ---原码
        //11111111 11111111 11111111 11111110 ---反码
        //11111111 11111111 11111111 11111111 ---补码
        //左移两位：
        //11111111 11111111 11111111 11111100 ---补码
        //11111111 11111111 11111111 11111011 ---反码
        //10000000 00000000 00000000 00000100 ---原码：-4
        System.out.println(num4);//-4

        int num5 = 3 >>> 2;
        //00000000 00000000 00000000 00000011
        //逻辑右移2位
        //00000000 00000000 00000000 00000000：0
        System.out.println(num5);//0
    }
}

七.运算符优先级

1.什么是运算符优先级
—— 运算符有不同的优先级，优先级就是表达式运算中的运算顺序

2.优先级运算符表

八.键盘输入语句

1.什么是键盘输入语句

在进行编写程序的时候，我们需要从键盘输入一些需要的值，这个时候，我们就需要键盘输入语句来解决

2.一个小case快速了解键盘输入语句

public class Test {
    public static void main(String[] args) {
        int data = 0;
        double num = 0;
        String str = "";
        //需要new一个对象用来使用键盘输入语句
        Scanner sc = new Scanner(System.in);
        data = sc.nextInt();//nextInt()则要输入整数
        num = sc.nextDouble();//nextDouble则要输入浮点数
        str = sc.next();//next()则要输入字符串

        System.out.println(data);
        System.out.println(num);
        System.out.println(str);
    }
}

3.键盘使用语句的步骤