技术教程 编程教程 binary与进制转换 正文

binary与进制转换

2023-03-11,

精华笔记：

    什么是二进制：逢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

    左移位运算：<<

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

    移位运算的数学意义：

笔记：

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

    2进制：

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

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

    将二进制每个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进制输出

    十六进制：逢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进制

    权:           8  4  2  1
    
2进制:  0001 1011 1010 1010 0101
    
16进制:  1    b    a    a    5-----------1baa5

权:           8  4  2  1
    
2进制:  0010 1111 1101 0100 0111 1011
    
16进制:   2   f    d    4    7    b------2fd47b

权:           8  4  2  1
    
2进制:  0010 1001 0101 1010 1011 1001
    
16进制:  2    9    5    a    b    9
    

    //演示16进制
    
int n = 0x2fd47b; //0x表示16进制
    
int m = 0b0010_1111_1101_0100_0111_1011; //0b表示2进制
    
System.out.println(Integer.toBinaryString(n)); //按2进制输出
    
System.out.println(Integer.toBinaryString(m));
    
System.out.println(Integer.toHexString(n)); //按16进制输出
    
System.out.println(Integer.toHexString(m));
    
System.out.println(n); //按10进制输出
    
System.out.println(m);

//演示8进制
    
int a = 067; //以0开头的表示8进制
    
System.out.println(a); //55(6个8加7个1)
    
/*
    
小面试题:-----8进制平时不用
    
int a = 068; 正确吗?
    
答:编译错误，因为0开头的表示8进制，最大的数为7
    
*/

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

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

    以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)

    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)11111111111111111111111111111010 = -1-1-4 = -6
    
4)11111111111111111111111111110111 = -1-8 = -9
    
5)11111111111111111111111111110101 = -1-2-8 = -11
    
6)11111111111111111111111111010011 = -1-4-8-32 = -45
    

    //负值的输出
    
int n = -45;
    
System.out.println(Integer.toBinaryString(n)); //以2进制输出
    
int m = -11;
    
System.out.println(Integer.toBinaryString(m)); //以2进制输出

    互补对称现象：-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
    

    int a = 2147483647; //int的最大值
    
a = a+1;
    
System.out.println(a); //-2147483648(int的最小值)

int b = -2147483648; //int的最小值
    
b = b-1;
    
System.out.println(b); //2147483647

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

    取反：~

    运算规则：0变1，1变0

    与运算：&

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

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

    n =       00010111 01110101 01111010 11110110----0x17757af6
    
m =       00000000 00000000 00000000 11111111----0xff
    
k = n&m = 00000000 00000000 00000000 11110110----0xf6

int n = 0x17757af6;
    
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 11011110  0xde
    
m       = 00000000 00000000 10011101 00000000  0x9d00
    
k = n|m = 00000000 00000000 10011101 11011110  0x9dde

int n = 0xde;
    
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

    n =        01101011 00111111 01011110 00111010----0x6b3f5e3a
    
m = n>>>1  00110101 10011111 10101111 00011101
    
k = n>>>2  00011010 11001111 11010111 10001110
    
g = n>>>8  00000000 01101011 00111111 01011110

int n = 0x6b3f5e3a;
    
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

    n =        01101110 10111100 00111011 00111011-------0x6ebc3b3b
    
m = n<<1   11011101 01111000 01110110 01110110
    
k = n<<2   10111010 11110000 11101100 11101100
    
g = n<<8   10111100 00111011 00111011 00000000

int n = 0x6ebc3b3b;
    
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;
    
int g = n<<3;
    
System.out.println(m); //10----相当于5*2
    
System.out.println(k); //20----相当于5*4
    
System.out.println(g); //40----相当于5*8
    
/*
    
  权:  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
    
*/

binary与进制转换的相关教程结束。

《binary与进制转换.doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!