如题，拜托大家，实在过不了关。

1.         //进制优化运算  
   
2. public static void trans(int num,int base,int offset)
   
3.   {
   
4.    if(num==0)
   
5.    {
   
6.     System.out.println(0);
   
7.     return;
   
8.    }
   
9.    char[] chs = {'1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
   
10.    char [] arr=new char [32];
    
11.    int pos = arr.length;
    
12.    while(num!=0)
    
13.    {
    
14.     int temp =num&base;
    
15.     arr[--pos]=chs[temp];
    
16.     num=num>>>offset;
    
17.    }
    
18.     for(int x=pos;x<arr.length ;x++ )
    
19.     {
    
20.      System.out.print(arr[x]);
    
21.     }
    
22.      System.out.println();
    
23.   }
    

复制代码

1. public class Demo {
   
2.         // 进制优化运算
   
3.         public static void main(String[] args) {
   
4.                 trans(60, 15, 4);
   
5.         }
   
6. 
   
7.         //num是要进行运算的数，base和offset这里进制的优化，有个规律是十进制转二进制&1再右移1位,
   
8.         //十进制转八进制&7右移3位，十进制转十六进制&15右移4位。这些就是进制转化的规律，就是共性的
   
9.         //内容，这里base&的数，offset是右移的位数
   
10.         public static void trans(int num, int base, int offset) {
    
11.                 if (num == 0) {//判断传进来的数，如果是0后面就不用再算了直接输出零
    
12.                         System.out.println(0);
    
13.                         return;//用来终止方法运行
    
14.                 }
    
15.                
    
16.                 char[] chs = { '0','1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
    
17.                                 'C', 'D', 'E', 'F' };
    
18.                
    
19.                 //定义一个临时数组，用来存储运算后的结果
    
20.                 char[] arr = new char[32];
    
21.                 //定义一个变量，为数组长度
    
22.                 int pos = arr.length;
    
23.                
    
24.                 while (num != 0) {//因为num一直右移，所以肯定会有num==0的时候，这是循环结束
    
25.                         //这里是转二进制就&1，八进制&7，十六进制&15
    
26.                         //定义一个变量记录&base之后的值
    
27.                         int temp = num & base;
    
28.                        
    
29.                         //temp的值作为角标从chs数组中找对应的
    
30.                         //然后存储到arr数组的末端，注意是先存储然后pos再做自减
    
31.                         arr[--pos] = chs[temp];
    
32.                        
    
33.                         //然后右移相应的位数
    
34.                         num = num >>> offset;
    
35.                 }
    
36.                 //遍历arr数组并打印，x=pos就是从数组的有效部位开始，pos在上面的运算中一直是递减的，而且是从数组的
    
37.                 //后面往前存储，在遍历时就可以做到类似于StringBuffer的反转功能
    
38.                 for (int x = pos; x < arr.length; x++) {
    
39.                         System.out.print(arr[x]);
    
40.                 }
    
41.                 System.out.println();
    
42.         }

复制代码

public static void trans(int num,int base, int offset)//创建一个trans的函数,有3个未知变量,分别是转换的num,取对应进制位进行&操作的base,无符号右移的位数offset.
        {
                if(num==0);
                {
                System.out.println(0);
                return ;
                }//先对传的数进行判断,如果是0,就直接打印0,不再进行转换操作;
               
                char[] chs={'0','1','2','3','4','5','6','7','8',
                                        '9','A','B','C','D','E','F'};//创建一个能够表示进制各位的数组
                char [] arr=new char [32];//创建一个能够临时存储进制各位的容器
                int pos=arr.length;//定义一个指针,让arr[pos]对应的就是容器中最后一位;目的是为了遍历时候打印顺序是正的.
                while(num!=0)//当num右移offset位后,如果num==0了,就代表这个数的进制转换有效位已经全部找出来了
                {
                        int temp=num&base;//与判断,取分别与1,7,15与操作;
                        arr[--pos]=chs[temp];//先让指针-1,即arr.legnth就是最后一位的角标,存进去
                        num=num>>>offset;//右移目的取前一位有效位
                }
                for(int x=pos;x<arr.length;x++)//进行遍历,打印出这个arr[]这个数组里的从arr[pos]开始的后几位.
                {
                        System.out.print(arr[x]);
                }

        }

燿陚√揚葳 发表于 2014-7-4 10:29

多谢了!

Adjin 发表于 2014-7-4 10:57
public static void trans(int num,int base, int offset)//创建一个trans的函数,有3个未知变量,分别是转换 ...

非常感谢!