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進制這兩個重要的轉換方法。