java 实现N进制转M进制

1. 把10进制转成N进制：除N取余，逆序排列

这里逆序排列使用StringBuilder类的reverse()函数来实现。

1.  
   /**
2.  
    * 10进制整数转换为N进制整数。 10进制转换为N进制的方法是：这个10进制数除以N,求出余数，并把余数倒叙排列。 除N取余，倒叙排列
3.  
    * @param tenRadix
4.  
    *            十进制整数
5.  
    * @param radix
6.  
    *            要转换的进制数，例如，要转成2进制数，radix就传入2
7.  
    * @return radix进制的字符串
8.  
    */
9.  
   public static String string10ToN(int tenRadix, int radix)
10.  
    {
11.  
        // 进制编码支持9+26=35进制
12.  
        String code = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
13.  
        StringBuilder buf = new StringBuilder();
14.  
        int remainder = 0;
15.  
        while (tenRadix != 0)
16.  
        {
17.  
            remainder = tenRadix % radix;// 求余数
18.  
            tenRadix = tenRadix / radix;// 除以基数
19.  
            buf.append(code.charAt(remainder));// 保存余数，记得要倒叙排列
20.  
        }
21.  
        buf.reverse();// 倒叙排列
22.  
        return buf.toString();
23.  
    }

2.把N进制数转成10进制数：按权展开

(1)这里的权就是N的ex次幂，例如2进制：1110=1*2^3+1*2^2+1*2^1+0*2^0 =8+4+2+0=14

所以这里需要一个求x的ex次幂的方法，这里用一个自定义的方法：

1.  
   /**
2.  
   * 返回x的ex次幂。
3.  
   * @param x
4.  
   * 底数
5.  
   * @param ex
6.  
   * 幂指数
7.  
   * @return x的ex次幂
8.  
   */
9.  
   public static int pow(int x, int ex)
10.  
    {
11.  
    int result = 1;
12.  
    for (int i = 0; i < ex; i++)
13.  
    {
14.  
    result *= x;
15.  
    }
16.  
    return result;
17.  
    }

当然也可以使用Math.pow()方法

下面是N进制转10进制的按权展开的方法：

1.  
   /**
2.  
    * 返回N进制对应的10进制数。
3.  
    *
4.  
    * @param N_num
5.  
    *            N进制数
6.  
    * @param radix
7.  
    *            N进制计数
8.  
    * @return N进制数对应的10进制数
9.  
    */
10.  
    public static int stringNTo10(String N_num, int radix)
11.  
    {
12.  
        StringBuilder stringBuilder = new StringBuilder(N_num);
13.  
        stringBuilder.reverse();// 反转字符，为了把权重最大的放在最右边，便于下面从左到右遍历，根据下标求权重。
14.  
        //如果不反转，从右向左遍历(从字符串下标大的一端)也可以
15.  
        char bitCh;
16.  
        int result = 0;
17.  
        for (int i = 0; i < stringBuilder.length(); i++)
18.  
        {
19.  
            bitCh = stringBuilder.charAt(i);
20.  
            if (bitCh >= '0' && bitCh <= '9')
21.  
            {
22.  
                // '0'对应的ASCII码整数：48
23.  
                result += (int) (bitCh - '0') * pow(radix, i);
24.  
            } else if (bitCh >= 'A' && bitCh <= 'Z')
25.  
            {
26.  
                // 减去'A'的ASCII码值(65),再加上10
27.  
                result += ((int) (bitCh - 'A') + 10) * pow(radix, i);
28.  
            } else if (bitCh >= 'a' && bitCh <= 'z')
29.  
            {
30.  
                // 减去'a'的ASCII码值(97),再加上10
31.  
                result += ((int) (bitCh - 'a') + 10) * pow(radix, i);
32.  
            }
33.  
        }
34.  
        return result;
35.  
    }

有了这两个核心的方法，其他的方法如十进制转2进制，十进制转8进制，十进制转16进制。N进制转M进制都可调用上面的两个方法来实现了：

3.N进制转M进制方法：

1.  
   /**
2.  
    * 把nRadix进制数nRadixNum转换为m进制数字符串并返回。
3.  
    * 具体做法是先把nRadix的nRadixNum转换成10进制数，然后再把这个10进制数转换成mRadix进制数。
4.  
    *
5.  
    * @param nRadixNum
6.  
    *            n进制数
7.  
    * @param nRadix
8.  
    *            n进制的基数
9.  
    * @param mRadix
10.  
     *            要转成的进制数基数m
11.  
     * @return m进制数字符串
12.  
     */
13.  
    public static String stringNToM(String nRadixNum, int nRadix, int mRadix)
14.  
    {
15.  
        return string10ToN(stringNTo10(nRadixNum, nRadix), mRadix);
16.  
    }

4.10进转2进制，10进制转8进制，10进制转16进制，调用十进制转N进制方法即可

1.  
   public static String string10To2(int tenRadixNum)
2.  
   {
3.  
   return string10ToN(tenRadixNum, 2);
4.  
   }
5.  
   public static String string10To8(int tenRadixNum)
6.  
   {
7.  
   return string10ToN(tenRadixNum, 8);
8.  
   }
9.  
   public static String string10To16(int tenRadixNum)
10.  
    {
11.  
    return string10ToN(tenRadixNum, 16);
12.  
    }

5.同理2进制转10进制，8进制转10进制，16进制转10进制，也只要调用N进制转10进制的方法即可，这里不再累赘。

6.整个代码：

1.  
   package lan.java.jinzhizhuanhuan;
2.  
    
3.  
   public class TheMoronicCowmpouter
4.  
   {
5.  
   public static void main(String[] args)
6.  
   {
7.  
   String HexNum = "f9";
8.  
   System.out.println(
9.  
   "16进制数：" + HexNum + "对应的2 进制数：" + stringNToM(HexNum, 16, 2));
10.  
    System.out.println(
11.  
    "16进制数：" + HexNum + "对应的10进制数：" + string16To10(HexNum));
12.  
    System.out.println(
13.  
    "16进制数：" + HexNum + "对应的32进制数：" + stringNToM(HexNum, 16, 32));
14.  
    }
15.  
    /**
16.  
    * 返回N进制对应的10进制数。
17.  
    *
18.  
    * @param N_num
19.  
    * N进制数
20.  
    * @param radix
21.  
    * N进制计数
22.  
    * @return N进制数对应的10进制数
23.  
    */
24.  
    public static int stringNTo10(String N_num, int radix)
25.  
    {
26.  
    StringBuilder stringBuilder = new StringBuilder(N_num);
27.  
    stringBuilder.reverse();// 反转字符
28.  
    char bitCh;
29.  
    int result = 0;
30.  
    for (int i = 0; i < stringBuilder.length(); i++)
31.  
    {
32.  
    bitCh = stringBuilder.charAt(i);
33.  
    if (bitCh >= '0' && bitCh <= '9')
34.  
    {
35.  
    // '0'对应的ASCII码整数：48
36.  
    result += (int) (bitCh - '0') * pow(radix, i);
37.  
    } else if (bitCh >= 'A' && bitCh <= 'Z')
38.  
    {
39.  
    // 减去'A'的ASCII码值(65),再加上10
40.  
    result += ((int) (bitCh - 'A') + 10) * pow(radix, i);
41.  
    } else if (bitCh >= 'a' && bitCh <= 'z')
42.  
    {
43.  
    // 减去'a'的ASCII码值(97),再加上10
44.  
    result += ((int) (bitCh - 'a') + 10) * pow(radix, i);
45.  
    }
46.  
    }
47.  
    return result;
48.  
    }
49.  
    public static int string2To10(String tenRadixNum)
50.  
    {
51.  
    return stringNTo10(tenRadixNum, 2);
52.  
    }
53.  
    public static int string8To10(String tenRadixNum)
54.  
    {
55.  
    return stringNTo10(tenRadixNum, 8);
56.  
    }
57.  
    public static int string16To10(String tenRadixNum)
58.  
    {
59.  
    return stringNTo10(tenRadixNum, 16);
60.  
    }
61.  
    /**
62.  
    * 返回x的ex次幂。
63.  
    *
64.  
    * @param x
65.  
    * 底数
66.  
    * @param ex
67.  
    * 幂指数
68.  
    * @return x的ex次幂
69.  
    */
70.  
    public static int pow(int x, int ex)
71.  
    {
72.  
    int result = 1;
73.  
    for (int i = 0; i < ex; i++)
74.  
    {
75.  
    result *= x;
76.  
    }
77.  
    return result;
78.  
    }
79.  
    /**
80.  
    * 10进制整数转换为N进制整数。 10进制转换为N进制的方法是：这个10进制数除以N,求出余数，并把余数倒叙排列。 除N取余，倒叙排列
81.  
    *
82.  
    * @param tenRadix
83.  
    * 十进制整数
84.  
    * @param radix
85.  
    * 要转换的进制数，例如，要转成2进制数，radix就传入2
86.  
    * @return radix进制的字符串
87.  
    */
88.  
    public static String string10ToN(int tenRadix, int radix)
89.  
    {
90.  
    // 进制编码支持9+26=35进制
91.  
    String code = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
92.  
    StringBuilder buf = new StringBuilder();
93.  
    int remainder = 0;
94.  
    while (tenRadix != 0)
95.  
    {
96.  
    remainder = tenRadix % radix;// 求余数
97.  
    tenRadix = tenRadix / radix;// 除以2
98.  
    buf.append(code.charAt(remainder));// 保存余数，记得要倒叙排列
99.  
    }
100.  
     buf.reverse();// 倒叙排列
101.  
     return buf.toString();
102.  
     }
103.  
     public static String string10To2(int tenRadixNum)
104.  
     {
105.  
     return string10ToN(tenRadixNum, 2);
106.  
     }
107.  
     public static String string10To8(int tenRadixNum)
108.  
     {
109.  
     return string10ToN(tenRadixNum, 8);
110.  
     }
111.  
     public static String string10To16(int tenRadixNum)
112.  
     {
113.  
     return string10ToN(tenRadixNum, 16);
114.  
     }
115.  
     /**
116.  
     * 把nRadix进制数nRadixNum转换为m进制数字符串并返回。
117.  
     * 具体做法是先把nRadix的nRadixNum转换成10进制数，然后再把这个10进制数转换成mRadix进制数。
118.  
     *
119.  
     * @param nRadixNum
120.  
     * n进制数
121.  
     * @param nRadix
122.  
     * n进制的基数
123.  
     * @param mRadix
124.  
     * 要转成的进制数基数m
125.  
     * @return m进制数字符串
126.  
     */
127.  
     public static String stringNToM(String nRadixNum, int nRadix, int mRadix)
128.  
     {
129.  
     return string10ToN(stringNTo10(nRadixNum, nRadix), mRadix);
130.  
     }
131.  
     }

运行结果：

1.  
   16进制数：f9对应的2 进制数：11111001
2.  
   16进制数：f9对应的10进制数：249
3.  
   16进制数：f9对应的32进制数：7P

这上面只支持到9+26=35进制以内的整数之间的进制相互转换，大于35进制的我不方便符号化就算了，知道进制转换的原理就行了，主要是10进制转N进制，以及N进制转10进制这两个重要的转换方法。