java 进制转换 十进制转二，八，十六进制

十进制转其他进制

因为在java中位运算符是直接对数值的二进制数进行操作的 并且 写的是二进制数在输出和操作时是以十进制数的形式；
所以十进制转二，八，十六进制；就已经实现了二进制，八进制，十进制，十六进制的相互转换。

1）十进制转其他进制&&其他进制的互相转换：使用这三种方式
2）其他进制转十进制：直接使用int、long即可

使用java API实现

十进制转二进制：Integer.toBinaryString();
十进制转八进制：Integer.toOctalString();
十进制转十六进制：Integer.tohexString();

class BaseSystemDemo1 {
	public static void main(String[] args) {
		//十进制转其他进制
		//1.使用java API实现

		//十进制转二进制
		int num=80;
		String BinStr=Integer.toBinaryString(num);

		//十进制转八进制
		String OctStr=Integer.toOctalString(num);

		//十进制转十六进制
		String HexStr=Integer.toHexString(num);

		System.out.println(BinStr);//1010000
		System.out.println(OctStr);//120
		System.out.println(HexStr);//50
	}
}

使用除基倒取余法实现

十进制转二进制

一个十进制数n，每次用n除以2，把余数记下来，再用商去除以2…依次循环，直到商为0结束，把余数倒着依次排列，就构成了转换后的二进制数

代码1：使用int类型

       //十进制转二进制
	   //1.方法1：除基倒取余法
	   //1_1:使用int类型
	   /*一个十进制数n，每次用n除以2，把余数记下来，
	   再用商去除以2...依次循环，直到商为0结束，
	   把余数倒着依次排列，就构成了转换后的二进制数*/
		int num=80;
		int r=0;//余数
		int t=0;//位数
		int bin=0;//最后的二进制数
		while(num!=0){
			r=num%2;
			num/=2;
			bin+=r*(int)(Math.pow(10,t));//每次求余后把余数存储在int型数的低位，依次递增
			t++;//位数加1
		}
		System.out.println(bin);//1010000

代码2：使用String类型

 //1_2:使用String类型
        int number=80;
		String strBin="";
		while(number!=0){
			// 0    0       ""
			// 00   0        0
			//...
			//1000   1      0000
			//number%2在strBin的前面，就是每次把新的余数放在字符串的首部，即实现了逆序余数
			strBin=number%2+strBin;
			number/=2;
		}
		System.out.println(strBin);//1010000

十进制转八进制

代码1：使用int类型

		//十进制转八进制
		//方法1：除基倒余法
		//1_1:使用int类型
		int num=80;
		int r=0;//余数
		int t=0;//位数
		int oct=0;//最后的八进制数
		while(num!=0){
			r=num%8;
			num/=8;
			oct+=r*(int)(Math.pow(10,t));
			t++;
		}
		System.out.println(oct);//120

代码2：使用String类型

//1-2：使用String类型
		int num1=80;
		String str="";
		while(num1!=0){
			str=num1%8+str;
			num1/=8;
		}
		System.out.println(str);//120

十进制转十六进制

因为十六进制是0-9，A-F，所以只能使用String存储
代码：

       //十进制转十六进制
		//方法1：除基倒余法
		//1:使用String类型
		int num2=842;
		String hexStr="";
		int n=0;
		while(num2!=0){
			n=num2%16;   
			//注意加上"",防止进行数值运算
			hexStr=((n>9)?(char)(n-10+'A')+"":n+"")+hexStr;
			num2/=16;
		}
		System.out.println(hexStr);//34A

使用位运算符&(按位与)与>>(右移)实现

十进制转二进制

n>>1 :无符号右移>>>,获取n的二进制的下一位
n&1：按位与&,刚好能够得到n的二进制的最低位；
再逐一输出即可
假设一共32位，减1(最后的一位不需要移动，本身就有1位数在最低位，所以-1)，再每次移动减少1位

代码1：直接输出

        //方法2：位运算>>>与&
		//2_1:直接输出
	     int n=80;
		 //从最高位开始移动，直到最低位
		 for(int i = 31;i >= 0; i--){
		/*
		n>>1 :无符号右移>>>,获取n的二进制的下一位
		n&1：按位与&,刚好能够得到n的二进制的最低位
		再逐一输出即可
		*/
         System.out.print(n >>> i & 1);//00000000000000000000000001010000
		 }
         System.out.println();

代码2：使用String类型

        //2_2:使用String
		 String str="";
		 int m=80;
		 for(int i=31;i>=0;i--){
			 str+=(m>>>i&1)+"";
		 }
		 System.out.println(str);//00000000000000000000000001010000

十进制转八进制

假设一共32位，减2(最后的三位不需要移动，但每次移动3位，最后会需要补充1位数，所以只需要-2)，再每次移动减少3位

代码1：直接输出

 //方法2:使用位运算符>>与&
	   //2-1:直接输出
	   int num2=80;
	   //假设一共8位，减2(最后的三位不需要移动，但每次移动3位，最后会需要补充1位数，所以只需要-2)，再每次移动减少3位
	   //000 000 000
	   for(int i=6;i>=0;i-=3){
           System.out.print((num2>>>i)&7);//120
	   }
	   System.out.println();
	   //假设一共32位，减2(最后的三位不需要移动，但每次移动3位，最后会需要补充1位数，所以只需要-2)，再每次移动减少3位
	    for(int i=30;i>=0;i-=3){
           System.out.print((num2>>>i)&7);//00000000120
	   }
	   System.out.println();

代码2：使用String类型

  //2-2：使用String类型
	   int num3=80;
       String octStr="";
	   for(int i=30;i>=0;i-=3){
           octStr+=(num2>>>i)&7;
	   }
	   System.out.println(octStr);//00000000120

十进制转十六进制的演化过程1

1.使用&15得到num的最后四位二进制数，每四位二进制数为1位十六进制数
2.因为输出时，都是以十进制来输出的，所以只需要把num3的十进制大于9的转换为A-F；并且因为输出的可能是数值也可能是字符，使用字符串类型
3.num3>>4获得倒数第二个四位二进制数；并重复上述操作
4.连接字符串

代码1

class BaseSystemDemo2 {
	public static void main(String[] args) {
		//十进制转其他进制
		//2.使用位运算符&(按位与)与>>(右移)实现
		//原理：位运算符是直接对数值的二进制形式进行操作的
		//n&1 n&7 n&15：按位与&,刚好能够得到n的二进制的最后的位数
		//n>>1 n>>3 n>>4:右移>>,获取n的二进制的下一段

		//十进制转十六进制
		//1)使用&15得到num的最后四位二进制数，每四位二进制数为1位十六进制数
		int num=80;
		int num3=num&15;
		//2)因为输出时，都是以十进制来输出的，所以只需要把num3的十进制大于9的转换为A-F
		//因为输出的可能是数值也可能是字符，使用字符串类型
		String HexStr1=(num3>9)?(char)(num3-10+'A')+"":num3+"";
		//3)num3>>4获得倒数第二个四位二进制数
		int num4=(num>>4)&15;
		String HexStr2=(num4>9)?(char)(num4-10+'A')+"":num4+"";
		//4）连接两个字符串
		String HexStr=HexStr2+HexStr1;

		System.out.println(HexStr);//50


	}
}

十进制转十六进制的演化过程2

假设一共32位，减4(最后的四位不需要移动，所以-4)，再每次移动4位
使用三元运算符输出其中大于9的字符：(n1>9)?(char)(n1-10+‘A’)+"":n1+""

代码1：直接输出

		//方法2：使用位运算符>>>和&
		//2-1：直接输出
		int num3=842;
		int n1=0;
		//假设一共8位，减4(最后的四位不需要移动，所以-4)，再每次移动4位
		for(int i=4;i>=0;i-=4){
			n1=(num3>>>i)&15;
			System.out.print((n1>9)?(char)(n1-10+'A')+"":n1+"");//4A
		}
		System.out.println();
		//假设一共32位，减4(最后的四位不需要移动，所以-4)，再每次移动4位
		int n2=0;
		for(int i=28;i>=0;i-=4){
            n2=(num3>>>i)&15;
			System.out.print((n2>9)?(char)(n2-10+'A')+"":n2+"");//0000034A			
		}
		System.out.println();

代码2：使用String

//2-2:使用String类型
		int num4=842;
		String hexStr1="";
		int n3=0;
		for(int i=28;i>=0;i-=4){
			n3=(num4>>>i)&15;
			hexStr1+=(n3>9)?(char)(n3-10+'A')+"":n3+"";
		}
		System.out.println(hexStr1);//0000034A