——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.键盘使用语句的步骤
1）导入键盘输入类所在的包，java.util.*
2）创建键盘输入类的对象
3）调用功能（要输入什么类型的值，则调用什么类型的功能）
![[C初阶笔记]P1](https://img-blog.csdnimg.cn/16541d45b4934e33b959eeaad4aafe16.png)
