十进制 （ 最能理解的帮助大家熟悉 进制 规则 ）

逢10进1的计数规则，日常中我们使用最多的计数方法

• 规则：逢10进1
• 数字只有：0 1 2 3 4 5 6 7 8 9
• 基数：10
• 权：… 10^5(十万) 10^4(万) 10^3(千) 10^2(百) 10^1(十) 1 0^0(个)

eg: 14 = 1*10^1+4*10^0 ; 114 = 1*10^2+1*10^1+4*10^0

十进制，每个珠子代表对应权的值

二进制（ 计算机采用的数制 ）

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

• 规则：逢2进1
• 数字只有：0 1
• 基数：2
• 权：… 2^5 2^4 2^3 2^2 2^1 2 ^0

4位 2进制做对比

• 十进制转二进制：

10进制转换成2进制，计算如上图

• 二进制转为十进制： 将一个2进制数每个1位置的 权值 相加即可

举例：0101 = 1*2^2+1*2^0 =5

二进制，每个珠子代表对应权值

十六进制

逢16进1的计数规则， 因为2进制书写太麻烦，所以常常用16进制来缩写2进制数字

• 规则：逢16进1
• 数字只有：0 1 2 3 4 5 6 7 8 9 a b c d e f 其中:A~F表示10~15
• 基数：16
• 权：… 16^5 16^4 16^3 16^2 16^1 16 ^0

为了更好的让机器识别十六进制，使用“0x”开头为表示十六进制。

举例：0x1234——–1个4096+2个256+3个16+4个1 = 4660

八进制 （ 重点：为了区别各种进制：八进制以0开头 ）

• 规则：逢8进1
• 数字只有：0 1 2 3 4 5 6 7
• 基数：8
• 权：… 8^5 8^4 8^3 8^2 8^1 8 ^0

举例：034——–3个8+4个1 =28

进制相互转换

 //二进制转十进制
  0101 = 0*2^3+1*2^2+0*2^2+1*2^0  =5
//八进制转十进制
 037 = 0*8^2+3*8^1+9*8^0  =31
//十六进制转十进制
 0x1f = 1*16^1+15*16^0 = 31

//如何缩写：将2进制从最低位开始，每4位2进制缩写为1位  就是16进制

//4位2进制
8 4 2 1  权
0 1 0 1  二进制4位

//每4位缩成1位 变成16进制
16进制：  4       f       0        5        7      a       f        e
二进制：0100 1111 0000 0101 0111 1010 1111 1110      =  0x4f057afe

16进制：   f      f  
二进制：1111 1111      =   0xff

16进制： 6 1 4 f 7 b b b   //16转2进制，每位转成4位2进制  
2进制： 0110 0001 0100 1111 0111 1011 1011 1011

16进制： 3 2  //16转2进制，每位转成4位2进制  
2进制：0000 0000 0000 0000 0000 0000 0011 0010  

补码（ 4位二进制为例 ）

计算机中处理 有符号数 (正负数)的一种编码方式， java 中的补码最小类型是int，32位数

• 补码的编码规则：

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

绿线，超过就补码

 int  n = -3;
//打印十进制
System.out.println(n);
//打印二进制方法
System.out.println(Integer.toBinaryString(n));

//补码规律： 如上图
/*
1) 0111为四位补码的最大值，规律是1个0和3个1，可以推导出：
     32位int型 补码最大值是 1个0和31个1-----（011111111...）
 2) 1000 为四位补码的最小值，规律是1个1和3个0，可以推导出：
      32位int型 补码最小值是 1个1和31个0 ------（10000000....）
3) 1111为补码的-1，规律是4个1，可以推导出：
       32位int型 的-1 是32个1  -------（111111111...）
  
  最大值加一 变成最小值，如图就很清楚了，因为它是一个圆，最大值挨着的就是最小值
  eg: 0111  加1  变成 1000  但是存在补码，所以就变成了最小值
*/
int max = 2147483647;
//打印int 最大值的二进制
System.out.println(Integer.toBinaryString(max));
//打印 最大值加1 是否变成最小的值
System.out.println(Integer.toBinaryString(max+1));  

• 二进制负数的理解：

1. 记住int型 -1的编码是32个1
2. 用-1 减去0位置的对应权值 。是计算负多少数的计算方法【 正数：累加计算1位置的对应权值 】

 //int型 -1 如下
1111 1111 1111 1111 1111 1111 1111 1111  ======-1
//计算是用-1 减去0位置的对应权值
1111 1111 1111 1111 1111 1111 1111 1101  ======-1-2 = -3

1111 1111 1111 1111 1111 1111 1111 1001  ======-1-4-2 = -7

1111 1111 1111 1111 1111 1111 1001 0111  ======-1-8-32-64 =-105
//以上就是负数的计算  是看0位置的权值  

互补对称

1. 公式：-n =~n+1
2. 结论：一个数的补码=这个数取反+1

补码图

 //取反
 二进制 : 0010  取反 1101   然后加1   变成1110  // 2取反-2  
二进制：1001 取反 0110   然后加1   变成0111 // -7取反为7
// 取反 1变成0  ，0变成1   

位运算

~取反（见：上面互补对称）

& 与运算 （有0则0）

 //规则
0 & 0 =0
0 & 1 =0
1 & 0 = 0
1 & 1 = 1

//权              7       b       b       b
n =             01111011 1011 1011
m =            00000000 1111 1111      = 0xff
k = n&m    00000000 1011 1011
// 位置对上   1 & 1 =1   其余都是0   就可以得出答案                                              

| 或运算 （有1则1）

 //规则
0 | 0 =0
0 | 1 =1
1 | 0 = 1
1 | 1 = 1

//权              7       b       b       b
n =             01111011 1011 1011
m =            00000000 1111 1111      = 0xff
k = n&m    01111011 1111 1111
// 位置对上   0 | 0 =0   其余都是1   就可以得出答案    

>>> 右移位运算

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

<< 左移位运算

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

注： 位运算符 和乘2 除2 在大多数时候是很相似的，可以进行替代，同时效率也会高的多，但是两者切记不能混淆 ；不能单纯理解就是乘2 或者 除2

位移运算图

二进制运算

 //        加运算：
//        0+0=0，0+1=1，1+0=1，1+1=10，（逢2进1）；
//        减运算：
//        1-1=0，1-0=1，0-0=0，0-1=1，（向高位借1当2）；
//        乘运算：
//        0×0=0，0×1=0，1×0=0，1×1=1，（只有同时为“1”时结果才为“1”）；
//        除运算：(二进制数只有两个数（0，1），因此它的商是1或0)
//        0÷1=0，1÷1=1

eg:  10100 - 1010 = 1010
//                10100
//                -1010
//             ——————————（不够就向前借1，当作2在计算）
//                 1010  

学习记录，参考于blog.csdn.net/jason13579