利用栈实现十六进制转换

快来打我* 2022-11-04 11:15 96阅读 0赞

拿到需求后自己写了一份，然后参考别人写的好的，修改之后重写了一个版本

# v1 #

import java.util.Deque;
    import java.util.LinkedList;
    
    /**
     * v1
     * 需求：利用栈将12500转换成十六进制的数
     */
    public class StackTest {
        public static void main(String[] args) {
            Deque<String> deque = new LinkedList<>();
            System.out.println(calculate(12500,deque));
        }
    
        /**
         *
         * @param number  即将转换的数字
         * @param deque    借用该栈存储
         * @return
         */
        public static String calculate(int number, Deque<String> deque){
            while(number!= 0 ){
                String leftNumber = number%16+"";  //余数
                number = number/16;  //每一次的被除数
                switch (leftNumber){
                    case "10":leftNumber = "A";break;
                    case "11":leftNumber = "B";break;
                    case "12":leftNumber = "C";break;
                    case "13":leftNumber = "D";break;
                    case "14":leftNumber = "E";break;
                    case "15":leftNumber = "F";break;
                    default: break;
                }
    
                deque.push(leftNumber);
            }
    
            if(number!=0){
                calculate(number,deque);  //利用递归
            }
    
            //转成字符串
            StringBuilder sb = new StringBuilder();
            while (!deque.isEmpty()){
                sb.append(deque.pop());
            }
            return sb.toString();
    
        }
    }

# v2 #

import java.util.Deque;
    import java.util.LinkedList;
    
    public class StackTest2 {
        public static void main(String[] args) {
            String result = toHex(12500);
            if(result.equalsIgnoreCase("30D4")){
                System.out.println("测试成功");
            }else{
                System.out.println("测试失败");
            }
        }
    
        public static String toHex(int number){
            int baseNumber = 16;//进制
            int leftNumber = 0; //余数
            Deque<String> deque = new LinkedList<>();
            while(number!=0){
                leftNumber = number % baseNumber;
                number = number / baseNumber;
    //            deque.push(String.format("%x",leftNumber));//可用方法1
                deque.push(Integer.toHexString(leftNumber)); //可用方法2
            }
    
            StringBuilder sb = new StringBuilder();
            while (!deque.isEmpty()){
                sb.append(deque.pop());
            }
            return sb.toString();
        }
    }

# 知识点： #

1、String.format("%x",leftNumber);   String 类有专门的格式化方法可将数字化成十六进制

2、Integer.toHexString(leftNumber);  Integer类有专门的将数字转换成十六进制字符串的方法

3、频繁进行字符串拼接时使用StringBuilder类

# 两个版本的compare #

1、v1使用了递归，v2使用了while循环，v1这里使用递归可以，不过这里使用循环没有很复杂，而且调用递归也会影响效率，最终还是觉得采用循环比较好

参考:[什么情况下可以用递归][Link 1]

2、v1使用了switch case语句，原因自己知识掌握的少，不清楚有现成的String类和Integer类可以用来转换

3、v1的测试方法太过敷衍，应该从正常的开发思维去处理，正常结果是怎么样的，异常结果又是什么样的

4、 v1的变量定义比较杂乱，v2变量名在方法体内前面就定义好，并进行初始化，比较好

5、方法名不能太广泛，需要定位该方法是做什么操作的。

[Link 1]: https://www.cnblogs.com/jiutiankunpeng/p/4485149.html