Java补码表和位移运算符

在java中数据都是以二进制的形式保存的。

 

但是我们看到的数据怎么是10进制的？

因为java展示之前会自动调用toString()方法

这里以4位2进制为例，4位2进制只能表示16个数，即0-15。但是自然界的数不只是只有正数，还有负数，怎么表示呢？

所以java采用如下方式表示，见下图：

如果按照上面的补码计算，那么7+1的结果结果就为-8,7+2的结果为-9；

底层存储的是二进制，但是通过显示给用户的就是对应的数

7用二进制表示为0111,加1后为1000，java底层保存的是二进制码为1000,但是显示的是1000对应的数，为-8；

溢出就是这样，一直循环。再比如7+16,结果还是7；

这也是为什么 (2^31-1) + 1 =  -2^31

一个数字n   n = n +(max+1)*2  相当于绕了一圈又回到这个数了！

　　          n = ~n+1;(max,min,0,-1除外)

关于位移运算符，见下面代码：

public class Binary {
	public static void main(String[] args) {
		//转换成2进制，用Integer.toBinaryString()
		//转换成16进制，用Integer.toHexString()
		int i = 89;
		System.out.println(Integer.toBinaryString(i));
		//parseInt()
		int a = Integer.parseInt("232");
		System.out.println(a);
		System.out.println(Integer.toBinaryString(a));
		System.out.println(Integer.toHexString(a));
		/**
		 * ~: 0-->1   1-->0
		 *    注意：00000001 --->  11111110
		 */
		System.out.println(~a);
		System.out.println(Integer.toHexString(~a));
		int n;
		int m;
		/**
		 * |  或
		 * 
		 * 0 | 0 = 0
		 * 0 | 1 = 1
		 * 1 | 0 = 1
		 * 1 | 1 = 0
		 * 
		 * 常用于数据的拼接
		 */
//		n = 00000000 00000000 00000000 10100010
//	    m = 00000000 00000000 10111000 00000000
//   	i = 00000000 00000000 10111000 10100010
	    n = 0xa2;
	    m = 0xb800;
	    i = n | m; //  0xb8a2;
	    System.out.println(Integer.toHexString(i));
	    /**
	     * & 与
	     * 
	     * 0 & 0 = 0
	     * 0 & 1 = 0
	     * 1 & 0 = 0
	     * 1 & 1 = 1
	     * 
	     * 常用语拆分截取数据
	     * 
	     * n = 00000000 00000000 00110100 10110101
	     * m = 00000000 00000000 00000000 11111111
	     * i = 00000000 00000000 00000000 10110101
	     */
	    n = 0x34b5;
	    m = 0xff;
	    i = n & m; //0xb5;
	    System.out.println(Integer.toHexString(i));
	    
	    /**
	     * >>> 逻辑右移
	     * n =     01010001 11000000 00000010 01011111
	     * n>>>1 = 001010001 11000000 00000010 0101111  1(右移后去掉，高位补0)
	     * 
	     * n  = 10100000 10110101 00101100 00100010
	     * c1 = 11111111 00000000 00000000 00000000
	     * c2 = 00000000 11111111 00000000 00000000
	     * c3 = 00000000 00000000 11111111 00000000
	     * c4 = 00000000 00000000 00000000 11111111
	     */
	    int b1,b2,b3,b4;
	    n = 0xa0b52c22;
	    //截取
	    //拆分成byte
	    b1 = (n>>24) & 0xff;
	    b2 = (n>>16) & 0xff;
	    b3 = (n>>8) & 0xff;
	    b4 = n & 0xff;
	    System.out.println(Integer.toHexString(b1));
	    System.out.println(Integer.toHexString(b2));
	    System.out.println(Integer.toHexString(b3));
	    System.out.println(Integer.toHexString(b4));
	    //拼接
	    //byte组合成int
	    n = b4 | (b3<<8) | (b2<<16) | (b1<<24);
	    System.out.println(Integer.toHexString(n));
	    /**
	     * >>:正数的时候高位为0 >>补0
	     * 	     负数的时候高位为1 >>补1
	     * 	以0开头的肯定是正数，以1开头的肯定是负数
	     */
	    /**
	     * <<:左移
	     * 		10进制中移动一位相当于源数据*10
	     * 		2进制中移动一位相当于源数据*2
	     * 2<<1   = 2*2
	     * 2<<2   = 2*4  = 2*(2*2)
	     * 2<<3   = 2*8  = 2*(2*2*2)  
	     * 20<<1  = 20*2 
	     * 20<<2  = 20*4 = 20*(2*2)
	     * 
	     * 位移n，相当于2的n次幂
	     */
	    System.out.println(2<<3);  //2*2*2*2=16
	    System.out.println(50<<4); //50*2*2*2*2=800
	}
}