进制转换器

package 进制转换器;


import java.util.Scanner;


public class Main {
    public static int from; //明确数据从那个进制进入
    static int to; // 转换后的进制


    public static void main(String[] args) {
        while (true) {
            //显示操作界面
            showMenu();
            //接收转换命令，判断是否结束程序
            boolean isExist = inputCmd();
            if (isExist) {
                break;
            }
            //接收数据
            String data = inputData(from);
            //转换
            String result = convert(from, to, data);


            System.out.println("转换后的值为：" + result);
        }


    }


    /**
     * 功能;将输入的数据实现进制转换
     *
     * @param from 初始进制，源进制
     * @param to   目标进制
     * @param data 待转换的数据
     * @return 返回转换后的结果
     */
    private static String convert(int from, int to, String data) {
        /*
         * 1、接收完数据之后，首先判断进制转换命令
         * 2、开始转换：
         *    转换有两种 ： 十进制到其他进制 和 其他进制转换为十进制
         * 3、然后我们就可以将这两种转换分别构造函数
         *    十进制转换为其他进制的函数decimalToX();
         *    其他进制转换为十进制的函数xToDecimal();
         */
        if (from == 10) {
            data = decimalToX(to, data);
        } else {
            data = xToDecimal(from, to, data);
        }
        return data;
    }


    /**
     * 功能：把其他进制转换为十进制
     *
     * @param from 初始进制
     * @param data 要转换的值
     * @return 返回十进制的字符
     */
    private static String xToDecimal(int from, int to, String data) {
        int base[] = new int[data.length()]; //存基数的幂
        //这是基数的幂
        if (data.length()<2){
            base[0] =1;
        }else {
            base[0] = 1;
            base[1] = from;
            int from1 = from;
            for (int i = 2; i < data.length(); i++) {
                from1 *= from;
                base[i] = from1;
            }
        }
        /*
        进来是数字的情况
         */
        if (from <= 10) {
            int sum[] = new int[data.length()]; //取得字符串中的数
            int sum_sum = 0; //存转换后十进制数
            //这是将data转换为int类型的
            int context = 0;
            for (int i = data.length() - 1; i >= 0; i--) {
                sum[context] = Integer.parseInt(String.valueOf(data.charAt(i)));
                context++;
            }
            for (int i = 0; i < data.length(); i++) {
                sum_sum += sum[i] * base[i];
            }
            data = String.valueOf(sum_sum);
        } else {
            /*
            十六进制的情况
             */
            char chars[] = data.toCharArray();
            int sum[] = new int[data.length()]; //取得字符串中的数
            int sum_sum = 0; //存转换后十进制数
            for (int i = 0; i < chars.length; i++) {
                if (Character.isDigit(chars[i])) {
                    sum[i] = Integer.parseInt(String.valueOf(data.charAt(i)));
                } else {
                    /*
                     输入的数是字母的情况
                     */
                    switch (data.charAt(i)) {
                        case 'a':
                            sum[i] = 10;
                            break;
                        case 'b':
                            sum[i] = 11;
                            break;
                        case 'c':
                            sum[i] = 12;
                            break;
                        case 'd':
                            sum[i] = 13;
                            break;
                        case 'e':
                            sum[i] = 14;
                            break;
                        case 'f':
                            sum[i] = 15;
                            break;
                    }
                }
            }
            int co = sum.length-1;
            for (int i = 0; i < data.length(); i++) {
                sum_sum += sum[co] * base[i];
                co--;
            }
            data = String.valueOf(sum_sum);
        }
        if (to == 10){ //如果转出的是十进制  就直接输出
            return data;
        }
          /*
            相反  是别的进制就调用decimalToX（）；
           */
        return  decimalToX(to, data);
    }


    /**
     * 功能：把十进制转换为其他进制
     *
     * @param to  目标进制
     * @param data  待转换的数据
     * @return  转换后的结果
     */
    private static String decimalToX(int to, String data) {
        String sum = "";  //用来存data余数
        System.out.println(to);
        int data1 = Integer.parseInt(data);
        while (data1 != 0) { //data1为0跳出循环
            int con = data1 / to;  //商
            int con1 = data1 % to;  //求余
            if (con1<to&&con1>=10){
                switch (con1){
                    case 10 :
                        sum += "a";
                        break;
                    case 11 :
                        sum += "b";
                        break;
                    case 12 :
                        sum += "c";
                        break;
                    case 13 :
                        sum += "d";
                        break;
                    case 14 :
                        sum += "e";
                        break;
                    case 15 :
                        sum += "f";
                        break;
                }


            }else{
                sum += con1; //把余数收集起来
            }
            data1 = con; //把商给data1  进行下一次
        }


        String sun = "";  // 因为进制转换 是把余数倒叙排列
        for (int i = sum.length() - 1; i >= 0; i--) {  //倒叙所以先取最后一个字符
            sun += String.valueOf(sum.charAt(i)); //  把取得的字符收集起来
        }
        return sun;
    }


    /**
     * 功能：接收用户要转换的数据需要验证数据的合法性
     *
     * @param from 参数  from 代表传入的数据类型
     * @return 返回值是：data  输入的数据
     */
    private static String inputData(int from) {
        Scanner sc = new Scanner(System.in);
        String data = "";
        boolean success = false;
        while (!success) {
            System.out.println("请输入一个" + from + "进制的数");
            data = sc.next().toLowerCase();
            //假设我们已经知道如何验证数据合法 validate()验证
            success = validate(data, from);
        }
        return data;
    }


    /**
     * 功能：验证数据是否合法(这个数据是自符串型)
     *
     * @param data 待验证的数据
     * @param from 形参  实际上表示的这个数的初始进制
     * @return true false  返回是不是合法
     */
    private static boolean validate(String data, int from) {
        /**
         * 1、把接收的数据转换成小写
         * 2、要判断每一个字符，所以要将字符串转换为字符
         * 3、因为要判断每一个字符，字符可能会很多，所以要考虑循环
         * 4、考虑循环的四个问题
         *
         * 假设我们已经有一个验证字符是否合法的函数isDigit（ch,from）
         */
        data = data.toLowerCase();//转换成小写
        for (int i = 0; i < data.length(); i++) {
            char ch = data.charAt(i);
            if (!isDigit(ch, from)) {
                return false;
            }
        }
        return true;
    }


    /**
     * 功能:验证字符是否合法
     *
     * @param c    输入字符串中的单个字符
     * @param from 初始的进制
     * @return true false 是不是满足小于初始进制
     */
    private static boolean isDigit(char c, int from) {
        /**
         * 我先判断他是几进制   因为十六进制特殊一点 有字符
         */
        if (from <= 10) {   //判断是不是十进制
            if (Character.isDigit(c)) {
                if (Integer.parseInt(String.valueOf(c)) < from) {  //Integer.parseInt(String.valueOf(c)) 将char转换成int类型 为的是和from比较
                    return true;    //如果字符合法  就返回true
                }
            }
        } else {
            if (c == 'a' || c == 'b' || c == 'c' || c == 'd' || c == 'e' || c == 'f') {   //十六进制有字符和数字 所以分开比较
                return true;
            } else if (Character.isDigit(c)) {   //这是判断十六进制的数字部分
                if (Integer.parseInt(String.valueOf(c)) < from) {
                    return true;
                }
            }
        }
        return false;
    }


    /**
     * 功能： 接收转换命令，判断是否结束程序
     *
     * @return 返回用户是否结束程序
     */
    private static boolean inputCmd() {
        System.out.print("请选择");
        Scanner sc = new Scanner(System.in);
        String cmd = sc.next().toUpperCase();
        switch (cmd) {
            case "A":
                from = 10;
                to = 2;
                break;
            case "B":
                from = 2;
                to = 10;
                break;
            case "C":
                from = 10;
                to = 8;
                break;
            case "D":
                from = 8;
                to = 10;
                break;
            case "E":
                from = 10;
                to = 16;
                break;
            case "F":
                from = 16;
                to = 10;
                break;
            case "G":
                from = 2;
                to = 8;
                break;
            case "H":
                from = 8;
                to = 2;
                break;
            case "I":
                from = 2;
                to = 16;
                break;
            case "J":
                from = 16;
                to = 2;
                break;
            case "K":
                return true;
            default:
                System.out.println("请输入正确指令");
        }
        return false;
    }


    /**
     * 功能：输出指令界面
     */
    private static void showMenu() {
        System.out.println("A：十进制=>二进制 \t B:二进制=>十进制");
        System.out.println("C：十进制=>八进制\tD:八进制=>十进制");
        System.out.println("E：十进制=>十六进制\tF:十六进制=>十进制");
        System.out.println("G：二进制=>八进制\tH:八进制=>二进制");
        System.out.println("I：二进制=>十六进制\tJ:十六进制=>二进制");
        System.out.println("k：退出");
    }
}