binary与进制转换

精华笔记：
<ol>什么是二进制：逢2进1的计数规则。计算机中的变量/常量都是按照2进制来计算的

• 2进制：
  
  
  
  • 规则：逢2进1
    
  • 数字：0  1
    
  • 基数：2
    
  • 权：128  64  32  16  8  4  2  1
    
  
  
• 如何将2进制转换为10进制：
  
  
  
  • 正数：将二进制每个1位置的权相加
    
  
  

十六进制：逢16进1的计数规则

• 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进制
  

补码：--------------------------了解

• 计算机处理有符号数(正负数)的一种编码方式
  
• 以4位2进制为例讲解补码的编码规则：
  
  
  
  • 计算的时候如果超出4位则高位自动溢出舍弃，保持4位不变
    
  • 将4位2进制数分一半作为负数使用
    
  • 最高位称为符号位，高位为1是负数，高位为0是正数
    
  
  
• 规律数：
  
  
  
  • 0111为4位补码的最大值，规律是1个0和3个1，可以推导出
    
    
    
    • 32位补码的最大值：1个0和31个1------(01111111111111111111111111111111)
      
    
    
  • 1000为4位补码的最小值，规律是1个1和3个0，可以推导出
    
    
    
    • 32位补码的最小值：1个1和31个0------(10000000000000000000000000000000)
      
    
    
  • 1111为4位补码的-1，规律是4个1，可以推导出
    
    
    
    • 32位补码的-1：32个1----------------------(11111111111111111111111111111111)
      
    
    
  
  
• 深入理解负值：
  
  
  
  • 记住32位二进制数的-1的编码：32个1
    
  • 负值：用-1减去0位置对应的权---------------负数
    
  
  
• 互补对称现象：-n=~n+1--------取反+1
  

位运算：---------------------了解

• 取反：~
  
  
  
  • 运算规则：0变1，1变0
    
  
  
• 与运算：&
  
  
  
  • 运算规则：逻辑乘法，见0则0
    
  
  
• 或运算：|
  
  
  
  • 运算规则：逻辑加法，见1则1
    
  
  
• 右移位运算：>>>
  
  
  
  • 运算规则：将2进制数整体向右移动，低位自动溢出舍弃，高位补0
    
  
  
• 
  左移位运算：</pulli运算规则：将2进制数整体向左移动，高位自动溢出舍弃，低位补0/li/ul/lilip移位运算的数学意义：/p/li/ul/li/olh2 id="笔记"笔记：/h2ollip什么是二进制：逢2进1的计数规则。计算机中的变量/常量都是按照2进制来计算的/pullip2进制：/pulli规则：逢2进1/lili数字：0  1/lili基数：2/lili权：128  64  32  16  8  4  2  1/li/ul/lilip如何将2进制转换为10进制：/pullip将二进制每个1位置的权相加即可---------------正数/p
  1. 权:    32  16  8  4  2  1
  2. 二进制: 1   0   1  1  0  1
  3. 十进制: 32+8+4+1=45

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

  复制代码
  /li/ul/li/ul/lilip十六进制：逢16进1的计数规则/pullip16进制：/pulli规则：逢16进1/lili数字：0 1 2 3 4 5 6 7 8 9 a b c d e f/lili基数：16/lili权：4096  256  16  1/li/ul/lilip用途：因为2进制书写太麻烦，所以常常用16进制来缩写2进制/p/lilip如何缩写：将2进制从低位开始，每4位2进制缩为1位16进制/p
  1. 权:           8  4  2  1
  2. 2进制:  0001 1011 1010 1010 0101
  3. 16进制:  1    b    a    a    5-----------1baa5
  4.    
  5. 权:           8  4  2  1
  6. 2进制:  0010 1111 1101 0100 0111 1011
  7. 16进制:   2   f    d    4    7    b------2fd47b
  8.    
  9. 权:           8  4  2  1
  10. 2进制:  0010 1001 0101 1010 1011 1001
  11. 16进制:  2    9    5    a    b    9

  复制代码
  1. //演示16进制
  2. int n = 0x2fd47b; //0x表示16进制
  3. int m = 0b0010_1111_1101_0100_0111_1011; //0b表示2进制
  4. System.out.println(Integer.toBinaryString(n)); //按2进制输出
  5. System.out.println(Integer.toBinaryString(m));
  6. System.out.println(Integer.toHexString(n)); //按16进制输出
  7. System.out.println(Integer.toHexString(m));
  8. System.out.println(n); //按10进制输出
  9. System.out.println(m);
  11. //演示8进制
  12. int a = 067; //以0开头的表示8进制
  13. System.out.println(a); //55(6个8加7个1)
  14. /*
  15. 小面试题:-----8进制平时不用
  16. int a = 068; 正确吗?
  17. 答:编译错误，因为0开头的表示8进制，最大的数为7
  18. */

  复制代码
  /li/ul/lilip补码：--------------------------了解/pullip计算机处理有符号数(正负数)的一种编码方式/p/lilip以4位2进制为例讲解补码的编码规则：/pulli计算的时候如果超出4位则高位自动溢出舍弃，保持4位不变/lili将4位2进制数分一半作为负数使用/lili最高位称为符号位，高位为1是负数，高位为0是正数/li/ul/lilip规律数：/pulli0111为4位补码的最大值，规律是1个0和3个1，可以推导出ulli32位补码的最大值：1个0和31个1------(01111111111111111111111111111111)/li/ul/lili1000为4位补码的最小值，规律是1个1和3个0，可以推导出ulli32位补码的最小值：1个1和31个0------(10000000000000000000000000000000)/li/ul/lili1111为4位补码的-1，规律是4个1，可以推导出ulli32位补码的-1：32个1----------------------(11111111111111111111111111111111)/li/ul/li/ul
  1. int max = Integer.MAX_VALUE; //int的最大值
  2. int min = Integer.MIN_VALUE; //int的最小值
  3. System.out.println(Integer.toBinaryString(max));  //01111111...
  4. System.out.println(Integer.toBinaryString(min));  //10000000...
  5. System.out.println(Integer.toBinaryString(-1));   //11111111...

  复制代码
  /lilip深入理解负值：/pullip记住32位二进制数的-1的编码：32个1/p/lilip负值：用-1减去0位置对应的权---------------负数/p
  1. 1)11111111111111111111111111111111 = -1
  2. 2)11111111111111111111111111111101 = -1-2 = -3
  3. 3)11111111111111111111111111111010 = -1-1-4 = -6
  4. 4)11111111111111111111111111110111 = -1-8 = -9
  5. 5)11111111111111111111111111110101 = -1-2-8 = -11
  6. 6)11111111111111111111111111010011 = -1-4-8-32 = -45

  复制代码
  1. //负值的输出
  2. int n = -45;
  3. System.out.println(Integer.toBinaryString(n)); //以2进制输出
  4. int m = -11;
  5. System.out.println(Integer.toBinaryString(m)); //以2进制输出

  复制代码
  /li/ul/lilip互补对称现象：-n=~n+1--------取反+1/p
  1. -7    = 11111111 11111111 11111111 11111001 = -1-2-4=-7
  2. ~-7   = 00000000 00000000 00000000 00000110 = 2+4=6
  3. ~-7+1 = 00000000 00000000 00000000 00000111 = 1+2+4=7
  4.    
  5. 5     = 00000000 00000000 00000000 00000101 = 1+4=5
  6. ~5    = 11111111 11111111 11111111 11111010 = -1-1-4=-6
  7. ~5+1  = 11111111 11111111 11111111 11111011 = -1-4=-5
  8.    
  9. 12    = 00000000 00000000 00000000 00001100 = 4+8=12
  10. ~12   = 11111111 11111111 11111111 11110011 = -1-4-8=-13
  11. ~12+1 = 11111111 11111111 11111111 11110100 = -1-1-2-8=-12

  复制代码
  1. //互补对称现象: -n=~n+1
  2. int n = -7;
  3. int m = ~n+1;
  4. System.out.println(m); //7
  5. int i = 12;
  6. int j = ~i+1;
  7. System.out.println(j); //-12

  复制代码
  1. int a = 2147483647; //int的最大值
  2. a = a+1;
  3. System.out.println(a); //-2147483648(int的最小值)
  5. int b = -2147483648; //int的最小值
  6. b = b-1;
  7. System.out.println(b); //2147483647

  复制代码
  /li/ul/lilip位运算：---------------------了解/pullip取反：~/pulli运算规则：0变1，1变0/li/ul/lilip与运算：&/pullip运算规则：逻辑乘法，见0则0/p
  1. 0 & 0 ---------> 0
  2. 0 & 1 ---------> 0
  3. 1 & 0 ---------> 0
  4. 1 & 1 ---------> 1

  复制代码
  1. n =       00010111 01110101 01111010 11110110----0x17757af6
  2. m =       00000000 00000000 00000000 11111111----0xff
  3. k = n&m = 00000000 00000000 00000000 11110110----0xf6
  4.                
  5. int n = 0x17757af6;
  6. int m = 0xff; //8位掩码
  7. int k = n&m;
  8. System.out.println(Integer.toBinaryString(n));
  9. System.out.println(Integer.toBinaryString(m));
  10. System.out.println(Integer.toBinaryString(k));
  11. 如上运算的意义:k中储的是n的最后8位，这种运算叫做掩码运算
  12.              一般从低位开始1的个数称为掩码的位数

  复制代码

或运算：|

• 运算规则：逻辑加法，见1则1
  1. 0 | 0 ----------> 0
  2. 0 | 1 ----------> 1
  3. 1 | 0 ----------> 1
  4. 1 | 1 ----------> 1

  复制代码
  1. n       = 00000000 00000000 00000000 11011110  0xde
  2. m       = 00000000 00000000 10011101 00000000  0x9d00
  3. k = n|m = 00000000 00000000 10011101 11011110  0x9dde
  4.    
  5. int n = 0xde;
  6. int m = 0x9d00;
  7. int k = n|m; //将n和m错位合并
  8. System.out.println(Integer.toBinaryString(n));
  9. System.out.println(Integer.toBinaryString(m));
  10. System.out.println(Integer.toBinaryString(k));

  复制代码

右移位运算：>>>

• 运算规则：将2进制数整体向右移动，低位自动溢出舍弃，高位补0
  1. n =        01101011 00111111 01011110 00111010----0x6b3f5e3a
  2. m = n>>>1  00110101 10011111 10101111 00011101
  3. k = n>>>2  00011010 11001111 11010111 10001110
  4. g = n>>>8  00000000 01101011 00111111 01011110
  5.    
  6. int n = 0x6b3f5e3a;
  7. int m = n>>>1;
  8. int k = n>>>2;
  9. int g = n>>>8;
  10. System.out.println(Integer.toBinaryString(n));
  11. System.out.println(Integer.toBinaryString(m));
  12. System.out.println(Integer.toBinaryString(k));
  13. System.out.println(Integer.toBinaryString(g));

  复制代码

左移位运算：