Java学习笔记_第一阶段_1.4 运算符
1.4 运算符
运算符介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
- 算术运算符
- 赋值运算符
- 关系运算符[比较运算符]
- 逻辑运算符
- 位运算符[需要二进制基础]
- 三元运算符
算术运算符
-
介绍
算术运算符是对数值类型的变量进行运算的，在Java程序中使用的非常的。
-
算术运算符一览
运算符 运算 范例 结果 + 正号 +7 7 - 负号 b=11;-b -11 + 加 9+9 18 - 减 10-8 2 * 乘 7*8 56 / 除 9/9 1 % 取模（取余） 11%9 2 ++ 自增（前）：先运算后取值
自增（后）：先取值后运算a=2;b=++a;
a=2;b=a++;a=3;b=3
a=3;b=2-- 自减（前）：先运算后取值
自减（后）：先取值后运算a=2;b=--a;
a=2;b=a--;a=1;b=1
a=1;b=1+ z字符串相加 "hsp"+"edu" "hspedu" 注：a % b = a - (int)a / b * b
public class ArithmetricOperator {
public static void main(String[] args) {
// /使用
System.out.println(10 / 4);//从数学来看是2.5，java中是2，因为两个整数运算结果还是整数
System.out.println(10.0 / 4);//java中是2.5
double d = 10 / 4;//java中10 / 4 = 2，2=>2.0
System.out.println(d);//是2.0
// %取模，取余
System.out.println(10 % 3); // 1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); // 1
System.out.println(-10 % -3); // -1
// ++的使用
int i = 10;
i++;//自增 等价于 i = i + 1 => i=11
++i;//自增 等价于 i = i + 1 => i=12
System.out.println("i=" + i)；//12
int j1 = 8;
int j2 = 8;
int k1 = ++j1;// 等价 j1=j1+1;k1=j1;
int k2 = j2++;// 等价 k2=j2;j2=j2+1;
System.out.println("k1=" + k1 + "j1=" + j1);//9 9
System.out.println("k2=" + k2 + "j2=" + j2);//8 9
}
}
作为独立语句使用：前++和后++都完全等价于i=i+1
作为表达式使用：前++：++i先自增后赋值；后++：i++先赋值后自增
例：
int i = 1;
i = i++;//规则使用临时变量：(1)temp=i;(2)i=i+1;(3)i=temp;
System.out.println(i);//1
int i = 1;
i = ++i;//规则使用临时变量：(1)i=i+1;(2)temp=i;(3)i=temp;
System.out.println(i);//2
关系运算符
-
介绍
- 关系运算符的结果都是boolean型，也就是要么是true，要么是false
- 关系表达式经常用在if结构的条件中或循环结构的条件中
-
关系运算符一览
运算符 运算 范例 结果 == 相等于 8==7 false != 不等于 8!=7 true < 小于 8<7 false > 大于 8>7 true <= 小于等于 8<=7 false >= 大于等于 8>=7 true instanceof 检查是否是类的对象 "hsp" instanceof String true -
细节说明
- 关系运算符的结果都是boolean型，也就是要么是true，要么是false
- 关系运算符组成的表达式，我们成为关系表达式，a>b
- 比较运算符"=="不能误写成"="
逻辑运算符
-
介绍
用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值
-
逻辑运算符一览
- 短路与 &&，短路或 ||，取反 !
- 逻辑与 &，逻辑或 |，逻辑异或 ^
a b a&b a&&b a|b a||b !a a^b true true true true true true false false true false false false true true false true false true false false true true true true false false false false false false true false -
&&和&
-
基本规则
名称 语法 特点 短路与&& 条件1&&条件2 两个条件都为true，结果为true，否则为false 逻辑与& 条件1&条件2 两个条件都为true，结果为true，否则为false -
使用区别
- &&短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false，效率高
- 逻辑与&：不管第一个条件是否为false，第二个条件都要判断，效率低
- 开发中，我们使用的基本是短路与&&，效率高
public class LogicOperator { public static void main(String[] args) { int age = 50; if(age > 20 && age < 90) { System.out.println("ok100"); } if(age > 20 & age < 90) { System.out.println("ok200"); } //区别 int a =4; int b = 9; if(a < 1 && ++b < 50) { System.out.println("ok300"); } System.out.println("a=" + a + "b=" + b);//4 9 if(a < 1 & ++b < 50) { System.out.println("ok300"); } System.out.println("a=" + a + "b=" + b);//4 10 } } -
-
||和|
-
基本规则
名称 语法 特点 短路或|| 条件1||条件2 两个条件中只要有一个成立，结果为true，否则为false 逻辑或| 条件1|条件2 只要有一个条件成立，结果为true，否则为false -
使用区别
- 短路或||：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
- 逻辑或|：不管第一个条件是否为 true，第二个条件都要判断，效率低
- 开发中，我们基本使用||
public class LogicOperator { public static void main(String[] args) { int age = 50; if(age > 20 || age < 30) { System.out.println("ok100"); } if(age > 20 | age < 30) { System.out.println("ok200"); } //区别 int a =4; int b = 9; if(a > 1 || ++b > 4) { System.out.println("ok300"); } System.out.println("a=" + a + "b=" + b);//4 9 if(a > 1 | ++b > 4) { System.out.println("ok300"); } System.out.println("a=" + a + "b=" + b);//4 10 } } -
public class LogicOperator {
public static void main(String[] args) {
boolean x = true;
boolean y = false;
short z = 46;
if((z++ == 46) && (y = true)) { //z:46->47
z++;//z:47->48
}
if((x = false) || (++z == 49)){ //z:48->49
z++;//z:49-50
}
System.out.println("z=" + z);//50
}
}
赋值运算符
-
介绍
赋值运算符就是将某个运算后的值，赋给指定的变量
-
赋值运算符的分类
-
基本赋值运算符 =
-
复合赋值运算符
+=，-=，*=，/=，%=等，重点讲解一个+=，其他的使用是一个道理
a += b; [等价 a = a + b;]
a -= b; [等价 a = a - b;]
-
-
赋值运算符特点
-
运算顺序从右往左
int num = a + b + c;
-
赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量值
int num1 = 20;
int num2 = 78 * 34 - 10;
int num3 = a;
-
复合赋值运算符等价于下面的效果
a += 3; 等价于 a = a + 3;
-
复合赋值运算符会进行类型转换
byte b = 2; b += 3;// b = (byte)(b + 2); b++;// b = (byte)(b + 1)
-
public class AssignOperator {
public static void main(String[] args) {
int n1 = 10;
n1 += 4;// n1 = n1 + 4
System.out.println(n1);// 14
n1 /= 3;// n1 = n1 /3 -> 4
System.out.println(n1);// 4
}
}
三元运算符
-
基本语法
条件表达式 ? 表达式1 : 表达式2;
-
运算规则
- 如果条件表达式为true，运算后的结果是表达式1；
- 如果条件表达式为false，运算后的结果是表达式2；
public class TernaryOperator {
public static void main(String[] args) {
int a = 10;
int b = 99;
//1. a > b 为false
//2. 返回 b--，先返回b的值，然后再 b - 1
//3. 返回的结果是99
int result = a > b ? a++ : b--;
System.out.println("result=" + result);// 99
System.out.println("a=" + a);// 10
System.out.println("b=" + b);// 98
}
}
-
使用细节
-
表达式1和表达式2要为可以赋给接收变量的类型（或可以自动转换）
public class TernaryOperator { public static void main(String[] args) { int a = 3; int b = 8; int c = a > b ? (int)1.1 : (int)3.4; //可以 double d = a > b ? a : b + 3; //可以，满足 int -> double } } -
三元运算符可以转成if--else语句
int res = a > b ? a++ : --b; if(a > b)res = a ++; else res = --b;
-
例：实现三个数的最大值
public class TernaryOperator {
public static void main(String[] args) {
int n1 = 55;
int n2 = 33;
int n3 = 123;
//思路
//1. 先得到n1和n2中最大数，先保存到max1
//2. 然后再求出max1和n3中最大数，保存到max2
int max1 = n1 >= n2 ? n1 : n2;
int max2 = max1 >= n3 ? max1 : n3;
System.out.println("最大数=" + max2);
//使用一条语句实现
int max = (n1 >= n2 ? n1 : n2) >= n3 ? (n1 >= n2 ? n1 : n2) : n3;
System.out.println("最大数=" + max);
//推荐使用第一种方法实现
}
}
优先级
-
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行
运算顺序 运算符 . () {} ; , R -> L ++ -- ~ !(data type) ++a L -> R * / % L -> R + - L -> R << >> >>> 位移 L -> R < > <= >= instanceof L -> R == != L -> R & L -> R ^ L -> R | L -> R && L -> R || L -> R ? : R -> L = *= /= %= R -> L += -= <<= >>= R -> L >>>= &= ^= |= - ()，{}等
- 单目运算 ++ --
- 算术运算符
- 位移运算符
- 比较运算符
- 逻辑运算符
- 三元运算符
- 赋值运算符
-
只有单目运算符、赋值运算符是从右向左运算的
二进制
-
进制介绍
对于整数，有四种表示方式：
- 二进制：0，1，满2进1。以0b或0B开头
- 十进制：0-9，满10进1
- 八进制：0-7，满8进1。以数字0开头表示
- 十六进制：0-9及A(10)-F(15)，满16进1。以0x或0X开头表示。此处的A-F不区分大小写
public class BinaryTest { public static void main(String[] args) { //n1 二进制 int n1 = 0b1010; //n2 十进制 int n2 = 1010; //n3 八进制 int n3 = 01010; //n4 十六进制 int n4 = 0X10101; System.out.println("n1=" + n1); System.out.println("n2=" + n2); System.out.println("n3=" + n3); System.out.println("n4=" + n4); } }十进制 十六进制 八进制 二进制 0 0 0 0 1 1 1 1 2 2 2 10 3 3 3 11 4 4 4 100 5 5 5 101 6 6 6 110 7 7 7 111 8 8 10 1000 9 9 11 1001 10 A 12 1010 11 B 13 1011 12 C 14 1100 13 D 15 1101 14 E 16 1110 15 F 17 1111 16 10 20 10000 17 11 21 10001 -
进制的转换（基本功）
第一组
-
二进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和
例：将0b1011转成十进制的数
-
八进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和
例：将0234转成十进制的数
\(0234 = 4 \times 8^0 + 3 \times 8^1 + 2 \times 8^2 = 4 + 24 + 128 = 156\)
-
十六进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和
例：将0x23A转成十进制的数
\(0\mbox{x}23\mbox{A} = 10 \times 16 ^{0} + 3 \times 16^{1} + 2 \times 16^{2} = 10 + 48 + 512 = 570\)
第二组
-
十进制转二进制
规则：将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制
例：将32转成二进制
34 / 2 = 17……0
17 / 2 = 8……1
8 / 2 = 4……0
4 / 2 = 2……0
2 / 2 = 1……0
1 / 2 = 0……1
32 = 0b100010 = 0b00100010
一个字节有八位，所以前面要用两个0填充
-
十进制转八进制
规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的八进制
例：将131转成八进制
131 / 8 = 16……3
16 / 8 = 2……0
2 / 8 = 0……2
131 = 0203
-
十进制转十六进制
规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制
例：将237转成十六进制
237 / 16 = 14……D(13)
14 / 16 = 0……E(14)
237 = 0xED
第三组
-
二进制转八进制
规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可
例：将0b11010101转成八进制
-
二进制转十六进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可
例：将0b11010101转成十六进制
第四组
-
八进制转二进制
规则：将八进制数每1位，转成对应的一个3位的二进制数即可
例：将0237转成二进制
-
十六进制转二进制
-
规则：将八进制数每1位，转成对应的一个4位的二进制数即可
例：将0x23B转成二进制
-
-
二进制在运算中的说明
- 二进制是逢2进位的进位制，0、1是基本算符
- 现代的电子计算机奇数全部采用的是二进制，因为它只是用0、1两个数字符号，非常简单方便，易于用电子方式实现，计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
-
原码、反码、补码（重点、难点）
- 二进制的最高位是符号位：0表示正数，1表示负数
- 正数的原码、反码、补码都一样（三码合一）
- 负数的补码 = 它的原码符号位不变，其他位取反
- 负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 - 1
- 0的反码、补码都是0
- java没有无符号数，换言之，java中的数都是有符号的
- 在计算机运算的时候，都是以补码的方式来运算的
- 当我们看运算结果的时候，要看他的原码（重点）
位运算符
-
java中有7个位运算
符号 含义 运算规则 & 按位与 两位全为1，结果位1，否则位0 | 按位或 两位有一个位1，结果为1，否则为0 ^ 按位异或 两位一个位0，一个为1，结果为1，否则为0 ~ 按位取反 0 -> 1，1 -> 0 >> 算数右移 低位溢出，符号位不变，并用符号位补溢出的高位 << 算数左移 符号位不变，低位补0 >>> 逻辑右移(无符号右移) 低位溢出，高位补0 注：
- 没有<<<符号
- 位运算是用补码来计算的
例：1. ~2 2. 2&3 3. 2|3 4. ~-2 5. -3^3
-
2的补码 = 2的原码 = 00000000 00000000 00000000 00000010
~2操作：11111111 11111111 111111111 11111101 => 运算后的补码
运算后的反码 11111111 11111111 11111111 11111100
运算后的原码 10000000 00000000 00000000 00000011
结果是 -3
-
2的补码 = 2的原码 = 00000000 00000000 00000000 00000010
3的补码 = 3的原码 = 00000000 00000000 00000000 00000011
2&3操作：00000000 00000000 00000000 00000010 => 运算后的补码
运算后的原码 00000000 00000000 00000000 00000010
结果是 2
-
2的补码 = 2的原码 = 00000000 00000000 00000000 00000010
3的补码 = 3的原码 = 00000000 00000000 00000000 00000011
2|3操作：00000000 00000000 00000000 00000011 => 运算后的补码
运算后的原码 00000000 00000000 00000000 00000011
结果是 3
-
-2的原码 10000000 00000000 00000000 00000010
-2的反码 11111111 11111111 11111111 11111101
-2的补码 11111111 11111111 11111111 11111110
~-2操作：00000000 00000000 00000000 00000001 => 运算后的补码
运算后的原码 00000000 00000000 00000000 00000001
结果是 1
-
-3的原码 10000000 00000000 00000000 00000011
-3的反码 11111111 11111111 11111111 11111100
-3的补码 11111111 11111111 11111111 11111101
3的补码 = 3的原码 = 00000000 00000000 00000000 00000011
-3^3操作：11111111 11111111 11111111 11111110 => 运算后的补码
运算后的反码 11111111 11111111 11111111 11111101
运算后的原码 10000000 00000000 00000000 00000010
结果是 -2
-
public class BitOperator { public static void main(String[] args) { int a = 1>>2; // 1 = 00000000 00000000 00000000 00000001 // => 00000000 00000000 00000000 00000000 = 0 int b = -1>>2; // -1的原码 10000000 00000000 00000000 00000001 // -1的反码 11111111 11111111 11111111 11111110 // -1的补码 11111111 11111111 11111111 11111111 // -1>>2 11111111 11111111 11111111 11111111 => 运算后的补码 // 结果 -1 int c = 1<<2; // 1 = 00000000 00000000 00000000 00000001 // => 00000000 00000000 00000000 00000100 = 4 int d = -1<<2; // -1的原码 10000000 00000000 00000000 00000001 // -1的反码 11111111 11111111 11111111 11111110 // -1的补码 11111111 11111111 11111111 11111111 // -1<<2 11111111 11111111 11111111 11111100 => 运算后的补码 // 运算后的反码 11111111 11111111 11111111 11111011 // 运算后的原码 100000000 00000000 00000000 00000100 // 结果 -4 int e = 3>>>2; // 1 = 00000000 00000000 00000000 00000011 // => 00000000 00000000 00000000 00000000 //a，b，c，d，e分别是多少 System.out.println("a=" + a); System.out.println("b=" + b); System.out.println("c=" + c); System.out.println("d=" + d); System.out.println("e=" + e); } }
