JSD-2204-API-进制-Day19

程序猿 Monkey

已于 2022-05-28 09:45:33 修改

阅读量195

点赞数

文章标签： java

于 2022-05-28 09:44:05 首次发布

本文链接：https://blog.csdn.net/TheNewSystrm/article/details/125014681

版权

本文介绍了2进制和16进制的基本概念，包括它们的计数规则、转换方法以及在计算机中的应用。深入探讨了补码，一种用于表示有符号数的编码方式，并通过实例解释了位运算，如取反、与、或和移位操作。最后，强调了判断二进制数正负的关键在于最高位，以及不同学习阶段的同学如何应对课程难度。

摘要由CSDN通过智能技术生成

1.什么是2进制

逢2进1的计数规则。计算机中的变量/常量都是按照2进制来计算的

- 2进制：

- 规则：逢2进1
- 数字：0 1
- 基数：2
- 权：128 64 32 16 8 4 2 1

- 如何将2进制转换为10进制：

- 将一个2进制数每个1位置的权相加即可-----------正数

       权:     32  16  8  4  2  1
       二进制:  1   0   1  1  0  1
       十进制:  32+8+4+1=45

     int n = 45; //编译时会被编译为:101101
     System.out.println(Integer.toBinaryString(n)); //以2进制输出
     System.out.println(n); //以10进制输出
     
     n++; //将101101增1----101110
     System.out.println(Integer.toBinaryString(n)); //以2进制输出
     System.out.println(n); //以10进制输出

2. 什么是16进制

- 16进制：

- 规则：逢16进1
- 数字：0 1 2 3 4 5 6 7 8 9 a b c d e f
- 基数：16
- 权：4096 256 16 1

- 用途：因为2进制书写太麻烦，所以常常用16进制来缩写2进制

- 如何缩写：将2进制从低位开始，每4个2进制缩为1位16进制

     权:             8 4 2 1
     2进制:  0010 1011 1010 0111 0101 1010
     16进制:  2    b    a    7    5    a------2ba75a
         
     权:             8 4 2 1
     2进制:  0001 1001 1101 1101 0101
     16进制:  1    9    d    d    5-----------19dd5

     int n = 0x2ba75a; //0x表示16进制
     int m = 0b0010_1011_1010_0111_0101_1010; //0b表示2进制
     System.out.println(Integer.toBinaryString(n)); //按2进制输出
     System.out.println(Integer.toBinaryString(m));
     System.out.println(n); //按10进制输出
     System.out.println(m);
     
     int a = 067; //以0开头表示8进制
     System.out.println(a); //55(6个8加上7个1--55)

3. 补码：---------------------了解

- 计算机处理有符号数(正负数)的一种编码方式

- 以4位2进制为例讲解补码的编码规则：

- 计算的时候如果超出4位则高位自动溢出舍弃，保持4位不变
- 将4位2进制数分一半作为负数使用
- 最高位称为符号位，高位为1是负数，高位为0是正数

- 规律数：最大值、最小值、-1

- 0111为4位补码的最大值，规律是1个0和3个1，可以推导出

----32位补码的最大值：1个0和31个1------(01111111111......)

- 1000为4位补码的最小值，规律是1个1和3个0，可以推导出

----32位补码的最小值：1个1和31个0------(10000000000......)

- 1111的4位补码为-1，规律是4个1，可以推导出

----32位补码的-1：32个1-----------------------(1111111111......)

       int max = Integer.MAX_VALUE; //int的最大值
       int min = Integer.MIN_VALUE; //int的最小值
       System.out.println(Integer.toBinaryString(max)); //01111111......
       System.out.println(Integer.toBinaryString(min)); //10000000......
       System.out.println(Integer.toBinaryString(-1));  //11111111......

- 深入理解负值：

- 记住32位二进制数的-1的编码为：32个1

- 负值：用-1减去0位置对应的权--------负数

       1)11111111111111111111111111111111 = -1
       2)11111111111111111111111111111101 = -1-2=-3
       3)11111111111111111111111111111001 = -1-2-4=-7
       4)11111111111111111111111111111000 = -1-1-2-4=-8
       5)11111111111111111111111101101011 = -1-4-16-128=-149
       6)11111111111111111111111101101100 = -1-1-2-16-128=-148

       int n = -148;
       System.out.println(Integer.toBinaryString(n));

- 互补对称现象：-n=~n+1----------取反+1

     -7    = 11111111 11111111 11111111 11111001 = -1-2-4=-7
     ~-7   = 00000000 00000000 00000000 00000110 = 2+4=6 
     ~-7+1 = 00000000 00000000 00000000 00000111 = 1+2+4=7    
         
     5     = 00000000 00000000 00000000 00000101 = 1+4=5
     ~5    = 11111111 11111111 11111111 11111010 = -1-1-4=-6
     ~5+1  = 11111111 11111111 11111111 11111011 = -1-4=-5
         
     12    = 00000000 00000000 00000000 00001100 = 4+8=12 
     ~12   = 11111111 11111111 11111111 11110011 = -1-4-8=-13
     ~12+1 = 11111111 11111111 11111111 11110100 = -1-1-2-8=-12

     //互补对称现象: -n=~n+1
     int n = -7;
     int m = ~n+1;
     System.out.println(m); //7
     
     int i = 12;
     int j = ~i+1;
     System.out.println(j); //-12

4. 位运算：-------------------了解

- 取反：~

- 0变1，1变0

- 与运算：&

- 运算规则：逻辑乘法，见0则0

       0 & 0 ------> 0
       0 & 1 ------> 0
       1 & 0 ------> 0
       1 & 1 ------> 1

                 1   7     9  d    5   d     9  e    
       n =      00010111 10011101 01011101 10011110
       m =      00000000 00000000 00000000 11111111  0xff 8位掩码
       k = n&m  00000000 00000000 00000000 10011110  0x9e
                     
       int n = 0x179d5d9e;
       int m = 0xff; //8位掩码
       int k = n&m;
       System.out.println(Integer.toBinaryString(n));
       System.out.println(Integer.toBinaryString(m));
       System.out.println(Integer.toBinaryString(k));
       如上运算的意义:k中存储的是n的最后8位，这种运算叫做掩码运算，一般从低位开始1的

- 或运算：|

- 运算规则：逻辑加法，见1则1

       0 | 0 -------> 0
       0 | 1 -------> 1
       1 | 0 -------> 1
       1 | 1 -------> 1

       n =      00000000 00000000 00000000 11011101  0xdd
       m =      00000000 00000000 10011101 00000000  0x9d00
       k = n|m  00000000 00000000 10011101 11011101  0x9ddd
           
       int n = 0xdd;
       int m = 0x9d00;
       int k = n|m; //将n和m错位合并
       System.out.println(Integer.toBinaryString(n));
       System.out.println(Integer.toBinaryString(m));
       System.out.println(Integer.toBinaryString(k));
       如上运算的意义:两个数的错位合并

- 右移位运算：>>>

- 运算规则：将2进制数整体向右移动，低位自动溢出舍弃，高位补0

                    6   7    d   7     8   f   6   d
       n =        01100111 11010111 10001111 01101101
       m = n>>>1  001100111 11010111 10001111 0110110
       k = n>>>2  0001100111 11010111 10001111 011011
       k = n>>>8  00000000 01100111 11010111 10001111 
       
       int n = 0x67d78f6d;
       int m = n>>>1;
       int k = n>>>2;
       int g = n>>>8;
       System.out.println(Integer.toBinaryString(n));
       System.out.println(Integer.toBinaryString(m));
       System.out.println(Integer.toBinaryString(k));
       System.out.println(Integer.toBinaryString(g));

- 左移位运算：<<

- 运算规则：将2进制数整体向左移动，高位自动溢出舍弃，低位补0

                    6   7    d   7     8   f   6   d
       n =        01100111 11010111 10001111 01101101
       m=n<<1     1100111 11010111 10001111 011011010
       k=n<<2     100111 11010111 10001111 0110110100
       g=n<<8     11010111 10001111 01101101 00000000
                      
       int n = 0x67d78f6d;
       int m = n<<1;
       int k = n<<2;
       int g = n<<8;
       System.out.println(Integer.toBinaryString(n));
       System.out.println(Integer.toBinaryString(m));
       System.out.println(Integer.toBinaryString(k));
       System.out.println(Integer.toBinaryString(g));

- 移位运算的数学意义：

     int n = 5;
     int m = n<<1;
     int k = n<<2;
     System.out.println(m);
     System.out.println(k);
     /*
              权:  64  32  16  8  4  2  1
              n:               0  1  0  1 = 5
              m:           0  1  0  1     = 10
              k:       0   1  0  1        = 20
              g:   0   1   0  1           = 40
     */