最清晰的进制转换讲解 - java实现

以你之姓@ 2024-04-18 23:59 0阅读 0赞

> *子曰：知之为不知，不知为不知，太菜也！*

进制转换在平时的算法练习题或者项目中都会遇到，下面我们来看一下使用java如何进行进制互相转换。

### 文章目录 ###

*   *   *   *  1. 使用内置函数进行进制转换
             *   *  十进制转换其他进制
                 *  其他进制转换十进制
             *  2. 模运算
             *   *  十进制到任意进制的转换
                 *  任意进制到十进制数的转换
             *  3. 位运算

#### 1. 使用内置函数进行进制转换 ####

在java函数中，`Integer`类中已经有相应函数可以进行十进制 与 二进制，八进制和十六进制的转换。

##### 十进制转换其他进制 #####

//十进制转成二进制 
    　　Integer.toBinaryString(int i) 
    　　//十进制转成八进制 
    　　Integer.toOctalString(int i) 
    　　//十进制转成十六进制： 
    　　Integer.toHexString(int i)

##### 其他进制转换十进制 #####

//二进制转十进制 
    　　Integer.valueOf("10111",2).toString()
    　　//八进制转成十进制 
    　　Integer.valueOf("188",8).toString() 
    　　//十六进制转成十进制 
    　　Integer.valueOf("ABC",16).toString()

使用java提供的函数进行进制转换只能进行二进制，八进制，十进制和十六进制间的转换，这可能还不能满足我们的需求，那么如何实现任意进制的转换呢。

#### 2. 模运算 ####

可以使用离散数学的模运算来进行进制的转换。具体的计算过程这里就不赘述了，下面是相应代码。

##### 十进制到任意进制的转换 #####

public static String Dec2Any(int n, int k) { 
            // 存放取模的栈
            Stack s = new Stack<Integer>();
    
            // 用来储存结果串
            StringBuffer result = new StringBuffer("");
    
            // 对十进制数字进行取模运算，余数压栈，除的结果进入下次循环
            while (n != 0) { 
                s.push(n % k);
                n = n / k;
            }
    
            // 将栈中的元素加入string中
            while (!s.isEmpty())
                result.append(s.pop());
    
            return result.toString();
        }

上面的代码需要注意一个问题，就是把十进制的数转为超过十进制的数字时，需要用相应的多进制表示符号替换。

##### 任意进制到十进制数的转换 #####

代码如下

public static int Any2Dec(String num,int k){ 
    
            // 最终产生的10进制结果
            int res = 0;
    
            // 用来记录个位，十位，百位...
            int flag = 0;
    
            // 从末尾一直遍历整个字符串（也就是从个位开始到最高位）
            for (int i = num.length()-1;i >= 0;i--)
            { 
                // 记录相对应的位置上的值
                int value = num.charAt(i);
                // 记录此位置上的单位大小，类比10进制就是 个位、十位、百位上的数字分别代表个十百
                int unit = (int)Math.pow(k, flag++);
    
                // 某一位置上的值 = 单价（个十百） * 数字
                if (num.charAt(i) >= 'A')
                    // 如果大于A表示，超过了10，要还原成数字
                    res += unit * (value -'A'+ 10);
                else
                    res += unit * (value -'0');
    
            }
            return res;
        }

#### 3. 位运算 ####

以前进行进制转换，我也只会想到使用模运算，但是后来通过查看java的Integer中进制转换的源码，发现java内部是使用位运算进行进制转换的。

我们首先看十进制到其他进制的转换，相应函数的源码如下

// 这里的i就是进制对应的二进制表示位数，8就是3位，16进制就是4位
       public static String toBinaryString(int i) { 
            return toUnsignedString(i, 1);
        }
       public static String toOctalString(int i) { 
            return toUnsignedString(i, 3);
        }
            public static String toHexString(int i) { 
            return toUnsignedString(i, 4);
        }

我们可以看到，内部是通过调用了`toUnsignedString（int i）`这个函数来实现进制转换的。

/** * 将整数转换为无符号数 */
        private static String toUnsignedString0(int val, int shift) { 
            // 确保转化位数的值在1-5之间，否则就会报错
            int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
            int chars = Math.max(((mag + (shift - 1)) / shift), 1);
            if (COMPACT_STRINGS) { 
                byte[] buf = new byte[chars];
                formatUnsignedInt(val, shift, buf, 0, chars);
                return new String(buf, LATIN1);
            } else { 
                byte[] buf = new byte[chars * 2];
                formatUnsignedIntUTF16(val, shift, buf, 0, chars);
                return new String(buf, UTF16);
            }
        }

这里对其中的一些值进行常亮解释

//用于表示二进制补码形式的值的位数
    public static final int SIZE = 32;

`numberOfLeadingZeros`函数解释

// 计算i当中第一个不为0的位置，最左边的一位，左边的值(0) < 右边的值(n)
     public static int numberOfLeadingZeros(int i) { 
           //返回32，如果指定值的补码表示形式中没有1出现
           if (i <= 0)
               return i == 0 ? 32 : 0;
           int n = 31;
           // 类似于二分法的查找
           // 如果i大于第十六为1的值，那么n的值在前16位，故 n = n -16
           // 此时i最左侧的值不会出现在后16位， >>>=16 表示右移的数目为16
           // 依次地推，直到最后找见1 的最左侧位
           if (i >= 1 << 16) {  n -= 16; i >>>= 16; }
           if (i >= 1 <<  8) {  n -=  8; i >>>=  8; }
           if (i >= 1 <<  4) {  n -=  4; i >>>=  4; }
           if (i >= 1 <<  2) {  n -=  2; i >>>=  2; }
           return n - (i >>> 1);
       }

因为我对位运算不是很熟悉，因此看起来还是挺有难度的，这里对函数进行一个解析，以十进制转为十六进制`toUnsignedString(i, 4)`为例。

*  int radix = 1 << shift这一行，把1左移4位，得到radix为16
 *  int mask = radix - 1得到mask为15，其二进制形式为00001111
 *  buf\[–charPos\] = digits\[i & mask\]中，i & mask的目的就是取i的最后4位，然后在digits表单中取到相应的十六进制字符。
 *  i >>>= shift，这一行，抛弃刚处理过的最后4位，往右再推4位，然后进入循环，直到i为0;  
    所有的十六进制的字符都放在了buf里面，然后组合成一个字符串，返回。

--------------------

我们可以通过改写这个函数，把十进制的数转换为任意2次方进制的数。

把其他进制转换为十进制时，内部是调用了`Integer的parseInt(String s, int radix)`方法。代码如下：

public static int parseInt(String s, int radix)
                    throws NumberFormatException
        { 
            /* * WARNING: This method may be invoked early during VM initialization * before IntegerCache is initialized. Care must be taken to not use * the valueOf method. */
    
            if (s == null) { 
                throw new NumberFormatException("null");
            }
    
            if (radix < Character.MIN_RADIX) { 
                throw new NumberFormatException("radix " + radix +
                                                " less than Character.MIN_RADIX");
            }
    
            if (radix > Character.MAX_RADIX) { 
                throw new NumberFormatException("radix " + radix +
                                                " greater than Character.MAX_RADIX");
            }
    
            int result = 0;
            boolean negative = false;
            int i = 0, len = s.length();
            int limit = -Integer.MAX_VALUE;
            int multmin;
            int digit;
    
            if (len > 0) { 
                char firstChar = s.charAt(0);
                if (firstChar < '0') {  // Possible leading "+" or "-"
                    if (firstChar == '-') { 
                        negative = true;
                        limit = Integer.MIN_VALUE;
                    } else if (firstChar != '+')
                        throw NumberFormatException.forInputString(s);
    
                    if (len == 1) // Cannot have lone "+" or "-"
                        throw NumberFormatException.forInputString(s);
                    i++;
                }
                multmin = limit / radix;
                while (i < len) { 
                    // Accumulating negatively avoids surprises near MAX_VALUE
                    digit = Character.digit(s.charAt(i++),radix);
                    if (digit < 0) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    if (result < multmin) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    result *= radix;
                    if (result < limit + digit) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    result -= digit;
                }
            } else { 
                throw NumberFormatException.forInputString(s);
            }
            return negative ? result : -result;
        }

核心代码是下面这部分

while (i < len) { 
                    // Accumulating negatively avoids surprises near MAX_VALUE
                    digit = Character.digit(s.charAt(i++),radix);
                    if (digit < 0) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    if (result < multmin) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    result *= radix;
                    if (result < limit + digit) { 
                        throw NumberFormatException.forInputString(s);
                    }
                    result -= digit;
                }

通过学习Inreger进制转换方法的实现过程，读者可以自己对其进行改造从而实现自己需要完成的功能。毕竟使用位运算进行进制转换的效率会高一些。

--------------------

版权声明：本文为CSDN博主「胡瓜\_」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/cwfjimogudan/article/details/53087303

--------------------

你懂了没？