进制和位的认识和理解

进制介绍

对于整数，有四种表示方式：

1. 二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。
2. 十进制：0-9 ，满 10 进 1。
3. 八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。
4. 十六进制：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 10 进制
        int n2 = 1010;
         //n3 8 进制
        int n3 = 01010;
         //n4 16 进制
        int n4 = 0X10101;
        System.out.println("二进制 n1=" + n1);
        System.out.println("10进制 n2=" + n2);
        System.out.println("8进制 n3=" + n3);
        System.out.println("16进制 n4=" + n4);
        System.out.println(0x23A);
    }
}

16进制	10进制	8进制	2进制
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
A	10	12	1010
B	11	13	1011
C	12	14	1100
D	13	15	1101
E	14	16	1110
F	15	17	1111
10	16	20	10000
11	17	21	10001

二进制转换成十进制

规则：从低位（右边）开始，将每个位上的数提出来，乘以2的（位数-1）次方，然后求和

案例：

0b1010=1*2的(1-1)次方+1*2的(2-1)次方+0*2的(3)次方+1*2的(4-1)次方法=1+2+0+8=11

八进制转换成十进制

规则：从低位（右边）开始，将每个位上的数提出来，乘以8的（位数-1）次方，然后求和

案例：

0234=4*8^0+3*8^1+2*8^2=4+124+128=156

十六进制转换成十进制

规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。

案例：

请将 0x23A 转成十进制的数
    0x23A = 10 * 16^0 + 3 * 16 ^ 1 + 2 * 16^2 = 10 + 48 + 51

十进制转换成二进制

规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。

 案例：请将 34 转成二进制 = 0B001000

十进制转换成八进制

规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。

请将 131 转成八进制 => 0203

十进制转换成十六进制

规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。

 案例：请将 237 转成十六进制 => 0xE

二进制转换成八进制

规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。

案例：请将 ob11010101 转成八进制 ob11(3)010(2)101(5) => 0325

二进制转换成十六进制

规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。

案例：请将 ob11010101 转成十六进制 ob1101(D)0101(5) = 0xD5

八进制转换成二进制

规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。

案例：请将 0237 转成二进制 02(010)3(011)7(111) = 0b100111

十六进制转换成二进制

规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。

案例：请将 0x23B 转成二进制 0x2(0010)3(0011)B(1011) = 0b0010001110

位运算的思考题

  public static void main(String[] args) {
        int a = 1 >> 2; // 1 向右位移 2 位
        int b = -1 >> 2;//算术右移
        int c = 1 << 2;//算术左移
        int d = -1 << 2;//
        int e = 3 >>> 2;//无符号右移
        
        //a,b,c,d,e 结果是多少
        System.out.println("a=" + a);//0
        System.out.println("b=" + b);//-1
        System.out.println("c=" + c);//4
        System.out.println("d=" + d);//-4
        System.out.println("e=" + e);//0
    }

 public static void main(String[] args) {
        System.out.println("按位取反" + (~2));//-3
        System.out.println("按位与 3   " + (2&3));//2
        System.out.println("按位或 3  " +(2|3));//3
        System.out.println("按位取反  " +(~-5));//4
        System.out.println("按位与   " +(13&7));//5
        System.out.println("按位或  " +(5|4));//5
        System.out.println("按位异或   " +(-3^3));//-2

    }

• 二进制是逢2位的进制位，0、1是基本算符
• 现代计算机全部是采用的是二进制，因为他只采用0、1两个数字符号，非常简单方便，易用于电子方式实现，计算机内部处理的信息，都是采用二进制树来表示的，二进制（binary）数用0、1及其组合来表示任何数字，，进位规则是逢二进一，数字1在不同的位上代表不同的数值，按从右至左的次序，这个值以二倍递增

原码，反码，补码

1. 二进制的最高位是符号位：0表示正数，1表示负数，（0->0  1->-）
2. 正数的原码，反码，补码，都一样（三码合一）
3. 负数的反码=它的原码符号位不变，其他位取反（0->1  1->0）
4. 负数的补码=他的反码+1，负数的反码=负数的补码-1
5. 0的反码，补码都是0
6. Java中没有无符号数，换言之，Java中的数都是有符号的
7. 在计算机运行的时候，都是以补码的方式来运算的
8. 当看到运算结果的时候，要看到他的原码

位运算符

• java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>)

  分别是 按位与& 、按位或|、按位异或^、按位取反~ 
  按位与&  : 两位全为1 ,结果为1，否则为0
  按位或|  : 两位有一位为1 ,结果为1，否则为0
  按位异或^ : 两位有一位为0 ,一个为1,结果为1，否则为0
  按位取反~ :  0->1,1->0
  

  public class BitOperator {
  	//编写一个main方法
  	public static void main(String[] args) {
  
  		//推导过程
  		//1. 先得到 2的补码 => 2的原码 00000000 00000000 00000000 00000010
  		//   2的补码 00000000 00000000 00000000 00000010
  		//2. 3的补码 3的原码 00000000 00000000 00000000 00000011
  		//   3的补码 00000000 00000000 00000000 00000011
  		//3. 按位&
  		//   00000000 00000000 00000000 00000010
  		//   00000000 00000000 00000000 00000011
  		//   00000000 00000000 00000000 00000010 & 运算后的补码
  		//   运算后的原码 也是  00000000 00000000 00000000 00000010
  		//   结果就是  2
  		System.out.println(2&3);//2
  
  		//推导
  		//1. 先得到 -2的原码 10000000 00000000 00000000 00000010
  		//2. -2的 反码 	    11111111 11111111 11111111 11111101
  		//3. -2的 补码       11111111 11111111 11111111 11111110
  		//4. ~-2操作        00000000 00000000 00000000 00000001运算后的补码
  		//5. 运算后的原码 就是 00000000 00000000 00000000 00000001 => 1
  		System.out.println(~-2);//1
  
  		//推导
  		//1. 得到2的补码 00000000 00000000 00000000 00000010
  		//2. ~2操作     11111111 11111111 11111111 11111101  运算后的补码
  		//3. 运算后的反码  11111111 11111111 11111111 11111100
  		//4. 运算后的原码  10000000 00000000 00000000 00000011=>-3
  		System.out.println(~2); //-3
  	}
  }
  

• 还有 3 个位运算符 >>、<< 和 >>> , 运

  算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位 、

  算术左移 <<: 符号位不变,低位补 0 3)

  >>>逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0 4)

  特别说明：没有 <<< 符

int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4