Susin3x's Blog
0%

javaSE基础学习day03

发表于 分类于
本文字数： 5.9k 阅读时长 ≈ 5 分钟
主要学习了进制和运算符，在408中学过原码转补码更快的方法，位运算符是java专有的。要区分=和==，逻辑与&和短路与&&，逻辑或|和短路或||，注意这些运算符在if-else结构中的运用。

进制

编程中经常涉及的进制及表示方式

  • 二进制（binary）：0,1 满2进1，以0b或0B开头
  • 十进制（decimal）：0-9 满10进1
  • 八进制（octal）：0-7 满8进1 以数字0开头
  • 十六进制（hex）：0-9及A-F 满16进1 以0x或0X开头

二进制

所有数字在计算机底层都以二进制形式存在。在计算机中参与运算的机器数有两大类：无符号数和有符号数，有符号数的机器表示有原码、反码、补码和移码。

  • 原码：直接将一个数值换成二进制数，最高位是符号位
  • 反码：符号位为0则反码与原码相同，符号位为1则数值位全部取反
  • 补码：符号位为0则补码与原码相同，符号位为1则数值位全部取反，末位加1

计算机底层都以补码的形式存储数据。

  • 负数[x]原转[x]补：从右往左找到第一个1，除符号位之外，这个1左边的所有位全部取反
  • [x]补转[-x]补：从右往左找到第一个1，这个1左边的所有位全部取反
    [-127]补 = 1000 0001 [-128]补 = 1000 0000

运算符

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

算术运算符（+，-，*，/，%，前++，后++，前–，后–，连接+）

运算符 运算 范例 结果
+ 正号 +3 3
- 负号 b=4;-b -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 5/5 1
% 取模(取余) 7%5 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=2;
+ 字符串连接 “He” + “llo” “Hello”
  • 除号的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分
1
2
int result = num1 / num2 * num2;
System.out.println(result);//10
  • 取模结果的符号与被模数的符号相同，取模运算的结果不一定总是整数
1
2
3
4
5
6
int m1 = -12;
int n1 = 5;
int m2 = 12;
int n2 = -5;
System.out.println("m1 % n1 = " + m1 % n1);//-2
System.out.println("m2 % n2 = " + m2 % n2);//2
  • 自增自减运算符是在运算结束前（前置自增自减运算符）或后（后置自增自减运算符）将变量的值加（或减）一，相较于+=和-=运算符，自增运算符更简洁，且可控制效果作用于运算前还是之后
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i);    //10
System.out.println("i1="+i1);//11
i = ++i1;
System.out.print("i="+i);    //12
System.out.println("i1="+i1);//12
i = i2--;
System.out.print("i="+i);    //20
System.out.println("i1="+i1);//12
i = i2--;
System.out.print("i="+i);    //20
System.out.println("i2="+i2);//19
i = --i2;
System.out.print("i="+i);    //18
System.out.println("i2="+i2);//18
  • 连接符“+”除字符串相加功能外，还能把非字符串转换成字符串
1
System.out.println("5+5="+5+5);//5+5=55

赋值运算符（=，+=，-=，*=，/=，%=）

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理

  • “=”支持连续赋值
1
2
int i1,i2;
i1 = i2 = 10;
  • 赋值运算符运算的结果不会改变变量本身的数据类型
1
2
3
short s1 = 10;
s1 = s1 + 2//编译失败，常量默认int型，从int转换到short可能会有损失
s1 += 2;   //不会改变本身变量的数据类型
  • 开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
1
2
num = num + 2;//方式一
num += 2;     //方式二 (推荐)
  • 开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
1
2
3
num = num + 1;//方式一
num += 1;     //方式二
num++;        //方式三： (推荐)

比较运算符（==，!=，<，>，<=，>=，instanceof）

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
instanceof 检查是否是类的对象 “Hello”instanceof String true
  • 比较运算符的结果是boolean类型，运算结果要么是true，要么是false
  • 运算符>，<，>=，<= 只能使用在数值类型（整型和浮点型）的数据之间
  • == 和 != 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间
1
2
3
4
Account acct1 = new Account(1000);
Account acct2 = new Account(2000);
boolean b1 = (acct1 == acct2);   //false比较两个Account是否是同一个账户。
boolean b2 = (acct1 != acct2);   //true
  • 比较运算符“==”不能误写成“=”，注意区分“==”和“=”
1
2
3
4
5
6
7
8
int i = 10;
int j = 20;
System.out.println(i == j);  //false
System.out.println(i = j);   //20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1); //ture

逻辑运算符(&逻辑与，&&短路与，|逻辑或，||短路或，逻辑非！，逻辑异或^)

逻辑运算符操作的都是boolean类型的变量，而且结果也是boolean类型。逻辑异或^ 与逻辑或|的不同之处是：当左右都为true时，结果为false，异或，追求的是“异”!

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时，二者都会执行符号右边的运算
    不同点：当符号左边是false时，&继续执行符号右边的运算， &&不再执行符号右边的运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
    System.out.println("我现在在北京");
}
else{
    System.out.println("我现在在南京");//输出
}
System.out.println("num1 = " + num1);//11

boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
    System.out.println("我现在在北京");
}
else{
    System.out.println("我现在在南京");//输出
}
System.out.println("num2 = " + num2);//10
  • 区分 | 与 ||
    开发中，推荐使用||
    相同点1：| 与 || 的运算结果相同
    相同点2：当符号左边是false时，二者都会执行符号右边的运算
    不同点：当符号左边是true时，|继续执行符号右边的运算， ||不再执行符号右边的运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
boolean b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
    System.out.println("我现在在北京");//输出
}
else{
    System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);//11

boolean b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
    System.out.println("我现在在北京");//输出
}
else{
    System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);//10

练习

1
2
3
4
5
6
boolean x = true;
boolean y = false;
short z = 42;
if((z++ == 42) && (y = true))z++;   //z=44
if((x = false) || (++z == 45))z++;
System.out.println("z=" + z);       //z=46

位运算符（<<，>>，>>>，&，|，^，~）

位运算是直接对整数的二进制进行的运算

运算符 运算 范例
<< 左移 3<<2=12 –>3 * 2 * 2=12
>> 右移 3>>1 –>3/2=1
>>> 无符号左移 3>>>1=1 –>3/2=1
& 与运算 6&3=2
| 或运算 6|3=7
^ 异或运算 6^3=5
~ 取反运算 ~6=7
6(0110)取反得(1001)，(1001)补转原得(1111)		 
1
2
3
4
5
6
7
8
int i = 21;
int m = 12;
int n = 5;
System.out.println("i << 2 : "+ (i<<2) );  //84
System.out.println("i << 27 : "+ (i<<27) );//负
System.out.println(" m & n :"+(m & n));    //4
System.out.println(" m | n :"+(m | n));    //13
System.out.println(" m ^ n :"+(m ^ n));    //9

<< ：在一定范围内，每向左移1位，相当于 * 2；>> ：在一定范围内，每向右移1位，相当于 / 2

运算符 细节
<< 空位补0，被移除的高位丢弃，空缺位补0
>> 被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1
>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补
& 二进制位进行&运算，只有1&1时结果是1，否则是0
| 二进制位进行|运算，只有0 | 0时结果是0，否则是1
^ 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1；1^0=1 , 0^1=1
~ 正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反

练习一：写出最高效的 2 * 8 的实现方式

答：2 << 3 或 8 << 1

练习二：交换两个变量的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int num1 = 10;
int num2 = 20;	
//方式一:推荐的方式
int temp;
temp = num1;
num1 = num2;
num2 = temp;
//方式二：
//好处：不用定义临时变量
//坏处：1.相加操作可能超出存储范围 2.有局限性：只能适用于数值类型
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
//方式三：使用位运算符 m = k ^ n = (m ^ n) ^ n
//有局限性：只能适用于数值类型
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;

三元运算符

  • 三元运算符的格式：(条件表达式) ? 表达式1 : 表达式2，条件表达式的结果为boolean类型
  • 表达式1和表达式2要求是一致的，三元运算符可以嵌套使用
  • 根据条件表达式真或假，决定执行表达式1，还是表达式2
    如果表达式为true，则执行表达式1；如果表达式为false，则执行表达式2
  • 凡是可以使用三元运算符的地方，都可以改写为if-else，反之不成立
  • 如果程序既可以使用三元运算符又可以使用if-else结构，那么优先选择三元运算符
1
2
3
4
5
6
7
8
9
10
//获取两个数的最大值
int m = 12,n = 5;
int max = (m > n)? m : n;
System.out.println("两个数的最大值为：" + max);

//改写为if-else
if (m >n){
    System.out.println(m);
}else{
    System.out.println(n);
  • 本文作者： susin3x
  • 本文链接： https://susin3x.cn/posts/30d07a4c.html
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！