10进制转其他进制方法有几种，最好可以编写出通用的方法，只需要通过参数的形式调用即可。
方法一：利用StringBuffer，对于16进制需要进行是否 大于9的判断，大于9需要转化成对应的字母表示，通过(char)（temp - 10 + 'A')

1. class ArrayTest5
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 toHex(60);
   
6.         }
   
7.        
   
8.         /*
   
9.            十进制-->十六进制,利用到StringBuffer。
   
10.         */
    
11.         public static void toHex(int num)
    
12.         {
    
13. 
    
14.                 StringBuffer sb = new StringBuffer();
    
15. 
    
16.                 for(int x=0; x<8; x++)
    
17.                 {
    
18.                         // 取低四位的值，15的二进制为0000 0000 0000 0000 0000 0000 0000 1111
    
19.                         int temp = num & 15;
    
20. 
    
21.                         // 如果大于9，对应相应的字母
    
22.                         if(temp>9)
    
23.                                 sb.append((char)(temp-10+'A'));
    
24.                         else
    
25.                                 // 把低四位的转化值添加到StringBuffer中
    
26.                                 sb.append(temp);
    
27. 
    
28.             //无符号右移4位
    
29.                         num  = num >>> 4;
    
30.                 }
    
31. 
    
32.                 // 反转输出结果
    
33.                 System.out.println(sb.reverse());
    
34.         }
    
35. 
    
36.         /*
    
37.             十进制-->二进制
    
38.         */
    
39.         public static void toBin(int num)
    
40.         {
    
41.                 StringBuffer sb = new StringBuffer();
    
42. 
    
43.                 while(num>0)
    
44.                 {
    
45.                         sb.append(num%2);
    
46.                         num = num / 2;
    
47.                 }
    
48. 
    
49.                 System.out.println(sb.reverse());
    
50.         }
    
51. }
    

复制代码

方法二：查表法。转化的数字通过数组来存储。

1. class ArrayTest6
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.             //toHex(60);
   
6.                 toBin(-6);
   
7.         }
   
8. 
   
9.         /*
   
10.                 十进制转化为二进制
    
11.         */
    
12.         public static void toBin(int num)
    
13.         {
    
14.                 //定义二进制的表。
    
15.                 char[] chs = {'0','1'};
    
16. 
    
17.                 //定义一个临时存储容器。
    
18.                 char[] arr = new char[32];
    
19. 
    
20.                 //定义一个操作数组的指针
    
21.                 int pos = arr.length;
    
22. 
    
23.                 while(num!=0)
    
24.                 {
    
25.                         int temp = num & 1;
    
26. 
    
27.                         arr[--pos] = chs[temp];
    
28. 
    
29.                         num = num >>> 1;
    
30.                 }
    
31. 
    
32.                 for(int x=pos; x<arr.length; x++)
    
33.                 {
    
34.                         System.out.print(arr[x]);
    
35.                 }
    
36.         }
    
37. 
    
38.         /*
    
39.                 0 1 2 3 4 5 6 7 8 9 A  B  C   D  E  F  ==十六进制中的元素。
    
40.                 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    
41. 
    
42.                 查表法：将所有的元素临时存储起来，建立对应关系。
    
43.                 每一次&15后的值作为索引去查建立好的表，就可以找对应的元素。
    
44.                 这样比 -10+'a'简单的多。
    
45. 
    
46.                 这个表怎么建立呢？
    
47.                 可以通过数据的形式来定义。
    
48.                 终于出结果了，但是是反着的，想要正过来可以通过StringBuffer reverse功能来完成，
    
49.                 也可以使用已经学习过的容器：数组来完成存储。
    
50.         */
    
51.         public static void toHex(int num)
    
52.         {
    
53.                 char[] chs = {'0','1','2','3'
    
54.                                         ,'4','5','6','7'
    
55.                                         ,'8','9','A','B'
    
56.                                         ,'C','D','E','F'};
    
57.                
    
58.                 //定义一个临时容器。
    
59.                 char[] arr = new char[8];
    
60.                 int pos = arr.length;
    
61. 
    
62.                 while(num!=0)
    
63.                 {
    
64.                         int temp = num & 15;
    
65.                        
    
66.                         arr[--pos] = chs[temp];       
    
67. 
    
68.                         num = num >>> 4;
    
69.                 }
    
70.                 System.out.println("pos="+pos);
    
71.                 //存储数据的arr数组遍历。
    
72.                 for(int x=pos;x<arr.length; x++)
    
73.                 {
    
74.                         System.out.print(arr[x]+",");
    
75.                 }
    
76. 
    
77.         }
    
78. }
    

复制代码

方法三：通用方法，通过参数传递决定转化进制。

1. class ArrayTest7
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                   toBin(-6);
   
6.                 //toHex(-60);
   
7.                 //toOctal(60);
   
8. 
   
9.         //System.out.println(Integer.toBinaryString(6));
   
10.              System.out.println(Integer.toHexString(6));
    
11.         }
    
12. 
    
13.         /*
    
14.                 十进制-->二进制
    
15.         */
    
16.         public static void toBin(int num)
    
17.         {
    
18.                 trans(num,1,1);
    
19.         }
    
20. 
    
21.         /*
    
22.                 十进制-->八进制
    
23.         */
    
24.         public static void toOctal(int num)
    
25.         {
    
26.                 trans(num,7,3);
    
27.         }
    
28.         /*
    
29.                 十进制-->十六进制
    
30.         */
    
31.         public static void toHex(int num)
    
32.         {
    
33.                 trans(num,15,4);
    
34.         }
    
35. 
    
36.     //通用的转换方法，传递的参数分别为：待转化数字、与运算的对应值、无符号右移的偏移量。
    
37.         //注意：这里的方法直接输出了转化后的值，返回值为void，而实际使用时大多需要范围值，范围值类型为String
    
38.         public static void trans(int num,int base,int offset)
    
39.         {
    
40.                 //如果带转化数字为0，直接输出0
    
41.                 if(num==0)
    
42.                 {
    
43.                         System.out.println(0);
    
44.                         return ;
    
45.                 }
    
46.                 char[] chs = {'0','1','2','3'
    
47.                                         ,'4','5','6','7'
    
48.                                         ,'8','9','A','B'
    
49.                                         ,'C','D','E','F'};
    
50.                 char[] arr = new char[32];
    
51. 
    
52.                 int pos = arr.length;
    
53. 
    
54.                 while(num!=0)
    
55.                 {
    
56.                         int temp = num & base;
    
57.                         arr[--pos] = chs[temp];
    
58.                         num = num >>> offset;
    
59.                 }
    
60. 
    
61.                 for(int x=pos; x<arr.length; x++)
    
62.                 {
    
63.                         System.out.print(arr[x]);
    
64.                 }
    
65. 
    
66.                 return ;
    
67.         }
    
68. }
    

复制代码

。。。。。。。。。。。。。。。。。。