java 位移，二进制、八进制、十进制、十六进制，超详解析！

 1.进制间的转换

1. public class HexConversion  {  
2.     /** 
3.      * TODO 进制转换。 
4.      * @param args 
5.      */  
6.     public static void main(String[] args)  {  
7.         /** 基本原理 二进制——>十进制   
8.          * 1101（2）=1*2^0+0*2^1+1*2^2+1*2^3=1+0+4+8=13 
9.          * 八进制——>十进制 
10.          * 1101（8）=1*8^0+0*8^1+1*8^2+1*8^3=1+0+64+512=577 
11.          * 425(8) = 5*8^0+2*8^1+4*8^2 = 5+16+256=277 
12.          * 十六进制——>十进制 
13.          * 1101（16）=1*16^0+0*16^1+1*16^2+1*16^3=1+256+4096=4353 
14.          * AF(16) = 15*16^0 + 10*16^1 = 15+160=175 
15.          * 二进制——>八进制 
16.          * (1100100)2=(001 100 100)2=(1 4 4)8=(9)2 
17.          * 二进制——>十六进制 
18.          * 1000 1001 1010 1011 1100 1101 1110 1111 =(89ABCDEF)16 
19.          */  
20.         //十进制的10格式化成16进制输出 "\n"换行  
21.         System.out.printf("%x \n", 10);  
22.   
23.         /**  十进制转二进制 
24.          * 4的二进制为100,2等于10  
25.          * 十进制18等于二进制4*4+2 = 10000+10  
26.          * result 10010 
27.          */  
28.         System.out.println("数值：为18的十进制转二进制:"+Integer.toBinaryString(18));  
29.           
30.         /** 方法二： 
31.          *  求102.8125的二进制 
32.          * 根据十进制转二进制换算 
33.          * 25除以2   12余1 
34.          * 12除以2    6余0 
35.          * 6除以2     3余0 
36.          * 3除以2     1余1 
37.          * 1除以2     0余1 
38.          * 十进制25的二进制为11001 
39.          *  
40.          * 十进制0.8125的二进制为： 
41.          * 小数乘以2，取整，小数部分继续乘以2，取整，得到小数部分0为止，将整数顺序排列 
42.          * 0.8125x2=1.625 取整1, 
43.          * 小数部分是0.625  0.625x2=1.25 取整1, 
44.          * 小数部分是0.25  0.25x2=0.5 取整0, 
45.          * 小数部分是0.5  0.5x2=1.0 取整1, 
46.          * 小数部分是0，结束 
47.          * 结果：11001.1101 
48.          */  
49.           
50.         /** 二进制转十进制 */  
51.         String v1 = "10010";  
52.         System.out.println("数值：为10010的二进制转十进制:"+Long.parseLong(v1,2));  
53.         //法二：  
54.         int r1 = (int)(0*Math.pow(2, 0)+1*Math.pow(2, 1)  
55.                 +0*Math.pow(2, 2)+0*Math.pow(2, 3)+1*Math.pow(2, 4));  
56.         System.out.println("法二: 数值：为10010的二进制转十进制:"+r1);  
57.           
58.           
59.         /** 十进制转八进制  
60.          * 十进制18等于八进制8，8，2 ； 10+10+2=22 
61.          * result 22 
62.          */  
63.         System.out.println("数值：为18的十进制转八进制:"+Integer.toOctalString(18));  
64.   
65.         /** 八进制转十进制  */  
66.         String v2 = "22";  
67.         System.out.println("数值：为22的八进制转十进制:"+Long.parseLong(v2,8));  
68.         //法二：  
69.         int r2 = (int)(2*Math.pow(8, 0)+2*Math.pow(8, 1));  
70.         System.out.println("法二: 数值：为22的八进制转十进制:"+r2);  
71.           
72.         /**  十进制转十六进制  
73.          * 十进制18等于十六进制16+2  
74.          * 十六进制16为10 
75.          * result 12 
76.          */  
77.         System.out.println("数值：为18的十进制转十六进制 :"+Integer.toHexString(18));  
78.         //法二：十六进制 xx*16的0次幂+xx*16的一次幂.......  
79.           
80.         /**  二进制换算成八进制 
81.          * 2的3次幂为8，所以以每3位作为二进制换算成八进制的单位  
82.          * 如下100的二进制为4,110为6,101为5,1为1 
83.          * result 4+6+5+1 = 16 
84.          */  
85.          String v3 = "100 110 101 1";  
86.     }  
87. }  

2.位移运算详解

 

[java] view plain copy print ?

1. public class Displacement  {  
2.     /**  TODO 位移运算详解。 
3.      * @param args 
4.      */  
5.     public static void main(String[] args)  {  
6.         /** 
7.          * ~ 位反 ~00110011 11001100    是0的就为1，是1的就为0 
8.          * & 位与 00110011&11101101 00100001 都为1的时候才为1 两个条件必须都成立 
9.          * | 位或 00110011|11100001 11110011 一个为1就取1，一个条件成立即可 
10.          * ^ 位异或 00110011^11100001 11010010 两个值都相同的时候取反，假如两个都为1，就取0 
11.          * << 左移 00110011<<2 11001100 x*2的y次幂 
12.          * >> 右移 10110011 >> 2 11101100 x/2y次幂（取整）,或者先将值换算成二进制数，int型32位，不满32为的往左补0一直补满32，然后将值右移要移动位数。在换算成10进制数输出  
13.          * >>> 不带符号右移 10110011>>2 00101100 
14.          */  
15.           
16.         /** << 左移   
17.          * 左移: 向左移动，右边补0。 
18.          * 公式：x<<y 即 x*2的y次方  
19.          * 详解 : 
20.          * p 方法一： 可以使用公式假如2<<3位 则公式为2*2的3次幂，结果：16 
21.          * p 方法二： 十进制的2，等价于二进制的10，左移是往右补0，所以往右补3个0 
22.          * 变成二进制的10000，将二进制的10000转成十进制就是：2的4次幂，结果：16 
23.          */  
24.         System.out.println(2<<3);  
25.         System.out.println("2左移8位等价于2乘以2的8次幂"+2*Math.pow(2,8));  
26.         //采用二进制换算  
27.         System.out.println(Math.pow(2,11));  
28.         //采用是公式2*2^3(2*2的3次幂)  
29.         System.out.println(2*Math.pow(2,10));  
30.           
31.         /** >> 右移   
32.          *  向右移动，如果符号位(int型为32位)为0，左边补0，符号位为1，左边补1   
33.          * 详解 
34.          * 例如102 >> 2  102除以2的2次幂，实际就是102/4取整，结果为：25 
35.          * 公式：x除以y取整 
36.          */  
37.         System.out.println(102>>2);  
38.           
39.         /** 15的二进制 
40.          * 0000 0000 0000 0000 0000 0000 0000 1111 
41.          * 往左补4个0得到： 
42.          * 0000 0000 0000 0000 0000 0000 0000 0000 
43.          * 结果：0 
44.          */  
45.         System.out.println(15>>4);  
46.           
47.         /** 15的二进制 
48.          * 0000 0000 0000 0000 0000 0000 0000 1111 
49.          * 往左补2个0得到： 
50.          * 0000 0000 0000 0000 0000 0000 0000 0011 
51.          * 结果：3 
52.          */  
53.         System.out.println(15>>2);  
54.           
55.         /**  有符号右移高位补1。  
56.          * 例如：-13 >> 3 
57.          * 13的原码：0000 1101，带符号所以高位为1，即：1000 1101 
58.          * -13的补码为高位不变，其他7位原码取反，再加1。 
59.          * 1000 1101取反:1111 0010，加1后为：1111 0011 
60.          * -13的补码：1111 0011 
61.          *  
62.          * 换算结果：-13右移3位，左边补1 ： 1111 1110 
63.          * 即：-13 >> 3的结果为：-2 
64.          * 看到这一步我想大家心里肯定有一个疑惑：明明是1111 1110，怎么结果变成了-2？ 
65.          * 那么答疑一下：2的二进制：0000 0010 (实际就是上面说的原码) 
66.          * 那么补码1111 1101，加1后：1111 1110 
67.          * 最高位代表符号位 
68.          * 所以结果为：-2 
69.          */  
70.         System.out.println(-13 >> 3);                 
71.           
72.         /** 无符号右移，无符号右移高位补0。 
73.          * -3 >>> 2 
74.          * 3的原码：0000 0000 0000 0000 0000 0000 0000 0011 
75.          * -3的补码：1111 1111 1111 1111 1111 1111 1111 1101 
76.          * 右移两位得到：0011 1111 1111 1111 1111 1111 1111 1111 
77.          */  
78.         //验证 将二进制111111111111111111111111111111转成十进制的结果是否和System.out.println(-3 >>> 2)一致。  
79.         System.out.println(Long.parseLong("111111111111111111111111111111", 2));  
80.         System.out.println(-3 >>> 2);  
81.     }  
82. }