Day0811---Java基础

一、Java进制

1. 十进制转二进制：

除2倒取余。

2. 引入八进制、十六进制：

计算机中二进制数字太长了，代码表示很繁琐， 引入八进制和十六进制，可以快速和简短表示二进制。

3. 二进制转八进制：

从最右边开始，三位一组，算成八进制数。
例：11001（二进制）= 31（八进制）
2 ^ 2 * 0 + 2 ^ 1 * 0 + 2 ^ 0 *1 = 1
2 ^ 1 * 1 + 2 ^ 0 * 1 =3

4. 八进制转十进制：

例：31 -> 3 * 8 ^ 1 +1 * 8 ^ 0 = 25

5. 二进制转十六进制：

从最右边开始，四位一组，算成十六进制数。

6. 进制表示：

十进制：正常写；
二进制：在数字前面加0b或0B；
八进制：在数字前面加0；
十六进制：在数字前面加0x或0X

7. 补码、原码、反码：

规定：
正数的原码、补码、反码三码合一；
负数的原码、补码、反码是不同的，因为计算机中把最高位（最左边的二进制位）定为符号位，0表示正数，1表示负数。
例：25
原码：0001 1001
反码：0001 1001
补码：0001 1001
例：-25
原码：0001 1001
反码：1110 0110（符号位不变，其余位取反）
补码：1110 0111（反码基础上末位加1）

8. 为什么byte类型的范围是-128~127：

byte是一个字节，一个字节是8位。
计算机中是使用“补码”形式来存储数据的。
正数：补码
0000 0001 -> 1
0111 1111 -> 127
负数：补码
1000 0001（反码1000 0000，原码 1111 1111）-> -127
1111 1111（反码1111 1110，原码1000 0001）-> -1
正0：0000 0000
负0：1000 0000（如果用它表示0会浪费，所以用来表示其他的数）
-127的二进制补码：1000 0001
1的二进制补码：0000 0001
-127 - 1 = （补码1000 0001 - 补码 0000 0001 = 补码 1000 0000）= -128
计算机中用符号位来表示正、负，就是为了底层设计的简化，让符号位也参与计算。

二、Java浮点型在底层如何存储

1. 小数涉及：

① 正数部分
② 小数部分
③ .

2. 化繁为简：

① 小数转为二进制：
整数部分：除2倒取余。
小数部分：十进制的小数部分转为二进制，乘2取整数部分。
② 把二进制用科学技计数法表示
用科学计数法表示后，对于二进制整数部分永远是1，则正数部分就不用存了，小数点也不用存了

3. 只要存三个内容：

① 正负号
② 挪完后的几次方（指数）
③ 二进制的小数部分（尾数）

4. 浮点型float和double在底层如何存储：

float：4个字节，被分为三个部分，最高位还是符号位，接下来的8位用来存指数部分，然后剩下的存尾数，存不下的尾数则舍去；
double：8个字节，被分为三个部分，最高位还是符号位，接下来的11位用来存指数部分，然后剩下的存尾数，存不下的尾数则舍去。

5. 注意：

① 浮点类型不精确，因为十进制的小数部分转二进制会需要舍去；
② float类型的4个字节能表示的数字范围比long类型的8个字节还要大，因为浮点型底层存的是指数。

三、Java基本数据类型之间的转换

1. 自动类型转换

int类型的值，赋值给了double类型的变量，那么他会自动升级为double。
① 把存储范围小的类型的值赋值给存储范围大的类型的变量，自动可以完成升级：byte->short->int->long->float->double，char->int；
② boolean不参与；
③ byte，short，char如果进行算术运算都会自动升级为int，
byte + byte / short + short / char + char 都会自动升级为int。

2. 强制类型

double类型的值，赋值给了int类型的变量，如果直接赋值编译会报错。
① 把存储范围大的类型的值，赋值给存储范围小的类型变量时，需要强制类型转换：double->float->long->int->short->byte，int->char；

byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1 + b2);

强制类型转换是有风险的：可能会溢出或损失精度。
② boolean不参与；
③ 当需要把存储范围小的变量，强制提升为存储范围大的类型时，也需要强制类型转换，没有风险。
整数/整数，结果还是整数，只保留整数部分。

3. 数据类型转换的特例：字符串类型

class Test{
	public static void main(String[] args){
		char c1 = '0';
		char c2 = '1';
		System.out.println(c1 + c2 + "");//97
		//c1和c2做求和运算为97，char+char结果是int，“”表示字符串，int和字符串拼接还是字符窜。
		System.out.println(c1 + "" + c2);//01
		//c1 + ""拼接运算，char+字符串结果是字符串，为“0”，“0” + c2拼接运算，字符串+char结果是字符串，结果是“01”
		System.out.println("" + c1 + c2);//01
		//"" + c1拼接运算，字符串+char结果是字符串，为“0”，“0” + c2拼接运算，字符串+char结果是字符串，结果是“01”
	}
}

所有类型与字符串做拼接运算，结果均为字符串。

四、Java运算符

1. Java算数运算符

+，－，*， /，%，++，–。
/：整数/整数，结果只保留整数部分；
%：被模数%模数，只看被模数的正负号；
++：自增；
–：自减。

n=++m：m先自增，然后把m的值取出来赋值给n；
q=p++：先取出p的值，放到一个"操作数栈"，p变量完成自增后，把放在"操作数栈"中的值赋值给q。
自增、自减的取值操作与自增操作一定是一前一后一起完成的。

int b=1;
int c=2;
int d=b++ + ++b + ++b  c++;
//b=4;c=3;d=12
//第一步b++：先取b的值为1，放到"操作数栈"，b自增为2
//第二步++b：先取b的值为2，自增为3，放到"操作数栈"
//第三步++b：先取b的值为3，自增为4，放到"操作数栈"
//第四步c++：先取c的值为2，放到"操作数栈"，c自增为3
//第五步：++b  c++ = 42，放到"操作数栈"
//第六步+：b++ + ++b + 12 = 1 + 3 +  8 = 12

PS：左边是String类型，右边是int类型，无法进行自动类型转换。

2. Java赋值运算符

=：永远是把等号右边的常量值，变量值，表达式计算值赋值给左边的变量，所以等号左边只能是一个变量，运算顺序是把等号右边表达式全算完才会做赋值操作。
+=，-=，=，/=，%=。

byte b1=1;
byte b2=2;
b2=b1+b2;//报错，右边byte+byte结果为int
b2+=b1;//b1=1，b2=3，等价于b2=(byte)(b2+b1)

3. Java比较运算符

<，>，<=，>=，= =，!=。
比较运算符计算后结果只有true和false
说明比较运算符饿表达式，可以作为判断条件和逻辑运算符的操作数。
比较运算符能够用于基本数据类型，不能用于引用数据类型，除了= =和!=。

一元运算符：操作数只有一个，
二元运算符：两个操作数，
三元运算符：三个操作数。

"xxx"+age<=18//操作数类型错误，先算了拼接，字符串和整型比较错误
"xxx"+(age<=18)//表达正确。

if(flag==true)//等价为if(flag)
if(flag=true)//赋值，结果为布尔值，编译可通过
if(num=1)//赋值，结果为整型，编译不可通过，因为只有布尔值可以作为条件。

4. Java逻辑运算符

逻辑与：&
类似于–且。
true&true→true
true&false→false
false&true→false
false&false→false
逻辑或：|
类似于–或。
true|true→true
true|false→true
false|true→true
false|false→false
逻辑非：!
类似于–取反。
!true→false
!false→true
逻辑异或：∧
类似于–求不同。
true∧true→false
true∧false→true
false∧true→true
false∧false→false
短路与：&&
结果：和&一样，
运算规则：如果&&左边已经是false，右边就不看了。
true&&true→true
true&&false→false
false&&？→false
false&&？→false
短路或：||
结果：和|一样，
运算规则：如果&&左边已经是true，右边就不看了。
true||true→true
true||false→true
false||true→true
false||false→false

int i=1;
int j;
if(i++ = = 1 && ++i = = 2){
j=1;
}else{
j=2;
}
//结果i=3，j=2
//第一步：先去i的值为1放起来，再自增，i的值为2
//第二步：作比较，i的值为1，==成立，&&左边结果为true，不会短路
//第三步：先自增，i的值为3，取i的值为3放起来
//第四步：作比较，i的值为3，==不成立，&&右边结果为false
//第五步：true与false做==运算，结果为false，if不成立，走else

int i=1;
int j;
if(i++ = = 1 || ++i = = 2){
j=1;
}else{
j=2;
}
//结果i=2，j=1
//第一步：先去i的值为1放起来，再自增，i的值为2
//第二步：作比较，i的值为1，==成立，||左边结果为true，发生短路，||右边不进行运算
//第三步：true||？，结果为true，if成立，走if

5. Java条件运算符

唯一的三元运算符，所以条件运算符也称三元运算符。
条件表达式？结果表达式1：结果表达式2
运算规则：如果条件表达式成立就取结果表达式1的值，如果不成立就取加过表达式2的值。

int x = 4;
int y = 2;
int max = x>=y ? x : y;

6. Java位运算符

效率很高，但可读性不好，基于二进制补码运算，在Java底层源代码中有很多使用。
左移：<<
运算规则：<<几位，就乘以2 的几次方；二进制补码左移n位，右边补0。
例：4<<3等价于42^3=48=32）
4的二进制：0000 0100
4<<3:0 0100000
右移：>>
运算规则：<<几位，就除以2 的几次方；二进制补码右移n位，左边补0还是1跟最高位相同。
例：32>>4等价于32/2^4=32/16=2）
32的二进制：0000 0000 0000 0000 0000 0000 0010 0000；
32>>4：0000 0000 0000 0000 0000 0000 0000 0010。
-32的二进制：
原码：1000 0000 0000 0000 0000 0000 0010 0000；
反码：1111 1111 1111 1111 1111 1111 1101 1111；
补码：1111 1111 1111 1111 1111 1111 1110 0000。
-32>>4：
补码：1111 1111 1111 1111 1111 1111 1111 1110；
反码：1111 1111 1111 1111 1111 1111 1111 1101；
原码：1000 0000 0000 0000 0000 0000 0000 0010。
无符号右移：>>>
运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后变为正数。
例：32>>>4，和32>>4结果一样
-32>>>4：
补码：0000 1111 1111 1111 1111 1111 1111 1110；
反码：0000 1111 1111 1111 1111 1111 1111 1101；
原码：0111 0000 0000 0000 0000 0000 0000 0010。
按位与：&
1&1结果是1
1&0结果是0
0&0结果是0
0&1结果是0
例：32&25：0000 0000 0000 0000 0000 0000 0000 0000；
32：0000 0000 0000 0000 0000 0000 0010 0000；
25：0000 0000 0000 0000 0000 0000 0001 1001。
按位或：|
1|1结果是1
1|0结果是1
0|0结果是0
0|1结果是1
例：32|25：0000 0000 0000 0000 0000 0000 0011 1001；
32：0000 0000 0000 0000 0000 0000 0010 0000；
25：0000 0000 0000 0000 0000 0000 0001 1001。
按位异或：^
1^1结果是0
1^0结果是1
0^0结果是0
0^1结果是1
例：32|25：0000 0000 0000 0000 0000 0000 0011 1001；
32：0000 0000 0000 0000 0000 0000 0010 0000；
25：0000 0000 0000 0000 0000 0000 0001 1001。
按位取反：~
一元运算符
~1结果是0
~0结果是1
例：~3=-4
3：0000 0000 0000 0000 0000 0000 0000 0011；
~3：补码：1111 1111 1111 1111 1111 1111 1111 1100：
反码：1111 1111 1111 1111 1111 1111 1111 1111 1011；
原码：1000 0000 0000 0000 0000 0000 0000 0000 0100。

7. Java运算符优先级（由低到高）

（1）赋值运算符优先级是最低的，即复制后运算；
（2）条件运算符
（3）|| 低于 && 低于 | 低于 ^ 低于 &
（4）比较运算符
（5）左移右移的位运算符
（6）算数运算符：=，- 低于 *，/ ，%。
（7）自增，自减，按位取反，非
（8）.（面向对象用），（）
关于&，|，^，看左右两边的操作数是boolean值还是整数，来决定是逻辑运算符还是位运算符。
注意：（1）表达式不要写太复杂，可以分多行
（2）如果非要混合运算，先算的用（）括起来

五、交换两个变量值的算法

int x = 1;
int y = 2;
//通用方案：适用于任意的数据类型，借助于第三个同样类型的临时变量。
int temp = x;
x=y;
y=temp;
//方案二：只是用与int类型
x = x ^ y;
y = x ^ y;//新的x ^ 原来的y = （原来的x ^ 原来的y）^原来的y = 原来的x（求不同）
x = x ^ y;//新的x ^ 新的y = （原来的x ^ 原来的y）^原来的x = 原来的y（求不同）
//方法三：只适用于int等整数类型，有奉风险可能会溢出
x = x + y;
y = x - y;//新的x - 原来的y = （原来的x + 原来的y）- 原来的y = 原来的x
x = x - y;//新的x - 新的y = （原来的x - 原来的y）- 原来的x = 原来的y
//类似的，用乘法，风险更大
x = x * y;
y = x / y;
x = x / y;

六、三个数中最大值

int max = (x >=y ? x : y) >= z ? (x >=y ? x : y) : z;