java里的进制

二进制：计算机只能处理二进制数据，利用编程语言提供的算法支持了十进制；计算机的内部（Java）只有二进制数据，在显示的时候编程语言提供API将二进制转换为十进制显示出来；计算机表面上支持了十进制，但其实不支持。
Java中有两个方法：
Integer.toString() 将二进制数据转换为十进制输出
Integer.parseInt() 将十进制字符串转换为二进制数据

		int n=45;
		System.out.println(n);//45，其实对n做了Integer.toString(n)。如下
		System.out.println(Integer.toString(n));//"45"
		System.out.println(Integer.toBinaryString(n));//101101
		int i=0;
		System.out.println(Integer.toBinaryString(i++));//0
		System.out.println(Integer.toBinaryString(i++));//1
		System.out.println(Integer.toBinaryString(i++));//10
		System.out.println(Integer.toBinaryString(i++));//11
		System.out.println(Integer.toBinaryString(i++));//100

十六进制：用于简写2进制（缩写二进制），原因是因为二进制的书写过于冗长，二进制的每四位缩写为一个十六进制数，按照这个规则可以将二进制缩写；编程时候凡是需要书写二进制数据的时候，都采用十六进制作为缩写。

//十六进制用于缩写二进制
		int n=0xb5;//十六进制
		System.out.println(Integer.toBinaryString(n));//二进制 ：10110101
		System.out.println(n);//十进制 ：181
		
		
		int m=0x5fdddb12;
		System.out.println(Integer.toBinaryString(m));//1011111110111011101101100010010 高位自动省略
		System.out.println(m);//1608375058

补码：是一种利用“正数”表示“负数”的算法，节省了硬件成本。

		int n=-1;
		System.out.println(Integer.toBinaryString(n));//11111111111111111111111111111111
		System.out.println(Integer.toBinaryString(-2));//11111111111111111111111111111110
		System.out.println(0);//0
		
		for(int i=-10;i<10;i++){
			System.out.print(Integer.toString(i)+" ");
			System.out.println(Integer.toBinaryString(i));
		}

		int max=Integer.MAX_VALUE;
		int min=Integer.MIN_VALUE;
		
		System.out.println(Integer.toBinaryString(max));//1111111111111111111111111111111
		System.out.println(Integer.toBinaryString(min));//10000000000000000000000000000000
		System.out.println(min-max);//1
		System.out.println(max+1);//-2147483648
		System.out.println(min-1);//2147483647
		
		int n=8;
		int m=n+(max+1)*4;
		System.out.println(m);//8
		
		//补码的对称现象：-n=~n+1
		n=8;
		System.out.println(~n+1);//-8
		System.out.println(Integer.toBinaryString(n));//1000
		System.out.println(Integer.toBinaryString(~n));//11111111111111111111111111110111
		System.out.println(Integer.toBinaryString(~n+1));//11111111111111111111111111111000

二进制的运算符：
1 ~取反
2.>>> >> <<移位运算
2.1) >>>逻辑右移位运算：将数字向右移动，高位补充0，低位溢出舍弃
n=01101101 00010001 11001001 10011011 m=n>>>1
m=001101101 00010001 11001001 1001101
2.2) <<逻辑左移位运算：将数字向左移动，低位补充0，高位溢出舍弃
2.3) >>>与>>
： >>> 向右移动，高位永远补0 ,负数时候不符合数学除法规律;
: >> 数位向右移动，高位为1（负数），则补1，高位为0（正数），则补0，保持符号位不变，其结果符合数学除法规律，自动向小方向取整
2.4)移位运算经典用途：与掩码运算配合，将数据进行拆分
3. & |与或运算
3.1) &与运算 逻辑乘法：1&1=1 0&1=0 1&0=0 0&0=0
计算规则：两个数上下对齐，对应位数进行与运算
d=01100011 00100110 00110111 11011110;
e=00000000 00000000 00000000 11111111
f=d&e;
f=00000000 00000000 00000000 11011110
经典用途：截取一个数据的后八位，称为掩码运算
3.2) |或运算：将数据进行合并
规则类似加法 1|1=1 0|1=1 1|0=1 0|0=0
计算规则：两个数上下对齐，对应位数进行或运算
b1=00000000 00000000 00000000 10011101
b2=00000000 00000000 00000000 01101111
b3=00000000 00000000 00000000 11101111
b4=00000000 00000000 00000000 00110011
n=(b1<<24)|(b2<<16)|(b3<<8)|b4
=10011101 00000000 00000000 00000000
00000000 01101111 00000000 00000000
00000000 00000000 11101111 00000000
00000000 00000000 00000000 00110011
=10011101 01101111 11101111 00110011

		int n=0x6d11c99b;
	//   >>>逻辑右移位运算
		int m1=n>>>1;
		int k1=n>>>2;
		System.out.println(Integer.toBinaryString(n));
		System.out.println(Integer.toBinaryString(m1));
		System.out.println(Integer.toBinaryString(k1));
		//   <<逻辑左移位运算
		int m2=n<<1;
		int k2=n<<2;
		System.out.println(Integer.toBinaryString(n));
		System.out.println(Integer.toBinaryString(m2));
		System.out.println(Integer.toBinaryString(k2));

		// >>>与>> 
		int a=-36;
		int b=a>>1;
		int c=a>>>1;
		System.out.print(a+" ");
		System.out.println(Integer.toBinaryString(a));
		System.out.print(b+" ");//b=-18
		System.out.println(Integer.toBinaryString(b));
		System.out.print(c+" ");
		System.out.println(Integer.toBinaryString(c));//??不符合数学规律
		
		//	&与运算
		//将int d拆分为4个八位数 f1 f2 f3 f4
		int d=0x632637de;
		int e=0xff;
		int f1=d&e;
		int f2=(d>>>8)&e;
		int f3=(d>>>16)&e;
		int f4=(d>>>24)&e;
		System.out.println(Integer.toBinaryString(d));//1100011 00100110 00110111 11011110
		System.out.println(Integer.toBinaryString(e));//11111111
		System.out.println(Integer.toBinaryString(f1));//11011110
		System.out.println(Integer.toBinaryString(f2));//110111
		System.out.println(Integer.toBinaryString(f3));//100110
		System.out.println(Integer.toBinaryString(f4));//1100011