二进制、十六进制和十进制的转换算法

梦里梦外; 2021-09-30 11:14 548阅读 0赞

## 一、二进制和十进制的转换 ##

/**
     * 十进制和二进制间的转换
     */
    public class IntToBinary {
        public static void main(String[] args) {
            int a = -23422;
            String str;
            System.out.println("======================使用自己写的方法=============================");
            str = intToBinaryString(a);
            System.out.println(str);
            System.out.println(binaryStringToInt(str));
            System.out.println("======================使用Integer中的方法=============================");
            str = Integer.toBinaryString(a);
            System.out.println(str);
    //        System.out.println(Integer.parseInt(binaryString, 2));    //只能转换正数，转换负数报错
            System.out.println(Integer.parseUnsignedInt(str, 2));
    
        }
    
        /**
         * int转二进制字符串
         *
         * 算法一：除2取余
         *  正数：除2取余-->倒序
         *  负数（补码）：先加1-->转换成正数-->除2取余，并取反-->高位补1-->倒序
         * @param num 整数
         */
        public static String intToBinaryString(int num){
            StringBuilder stringBuilder = new StringBuilder();
            boolean flag = false;   //标志：true表示为负数
            int rem;
            if (num == 0){
                return "0";
            }else if(num < 0){
                flag = true;
                num = Math.abs (num + 1);
            }
    
            while (num != 0){
                //正数，保持不变；负数，取反
                rem = (!flag && num % 2 == 0) || (flag && num % 2 == 1) ? 0 : 1;
                num = num / 2;
                stringBuilder.append(rem);
            }
    
            //判断是否为负数，如果是负数，那么前面所有位补1
            if(flag){
                num = stringBuilder.length();
                for(int i = 1; i <= 32 - num; i++){
                    stringBuilder.append("1");
                }
            }
    
            return stringBuilder.reverse().toString();
    
        }
    
        /**
         * int转二进制字符串
         *
         * 算法二：原数据的每一位和1进行与运算，判断1和0
         * @param num 整数
         */
        public static String intToBinaryString2(int num){
            StringBuilder stringBuilder = new StringBuilder();
            boolean flag = false;   //标志：true表示为负数
    
            for(int j=31;j>=0;j--) {
    
                if (((1 << j) & num) != 0){
                    flag = true;
                    stringBuilder.append("1");
                } else{
                    if (flag){
                        stringBuilder.append("0");
                    }
                }
            }
    
           return stringBuilder.toString();
    
        }
    
        /**
         * 二进制字符串转int
         *
         * 算法一：每位数字* 2的n-1次方，并相加
         * @param binaryStr 二进制字符串
         */
        public static int binaryStringToInt(String binaryStr){
            int result =0, rem;
    //        //正序遍历
    //        for (int i = 0; i < binaryStr.length(); i++){
    //            char c = binaryStr.charAt(i);
    //            rem = c - '0';
    //
    //            //使用Math.pow()方法，计算2的n-1次方
                result += rem * (int) Math.pow(2, (binaryStr.length() - 1 - i));
    //
    //            //使用位移，计算2的n-1次方
    //            result += rem << (binaryStr.length() - 1 - i);
    //        }
    
            //倒序遍历
            int _pow = 1;
            for (int i = binaryStr.length() - 1; i >= 0 ; i--){
                char c = binaryStr.charAt(i);
                rem = c - '0';
    
                result += rem * _pow;
    //            _pow = (int) Math.pow(2, (binaryStr.length() - i));  //使用Math.pow()方法，计算2的n-1次方
                _pow = _pow << 1;   //使用位移，计算2的n-1次方
            }
           return result;
        }
    
        /**
         * 二进制字符串转int
         *
         * 算法二：使用二进制转十进制的逆运算：被除数 = 除数 * 商 + 余数
         * @param binaryStr 二进制字符串
         */
        public static int binaryStringToInt2(String binaryStr){
            int result =0, rem, temp;
            for (int i = 0; i < binaryStr.length(); i++){
                char c = binaryStr.charAt(i);
                rem = c - '0';  //计算出二进制值0或1
                //使用二进制转十进制的逆运算：被除数 = 除数 * 商 + 余数
                result = result * 2 + rem;
            }
           return result;
        }
    }

## 二、十六进制和十进制的转换 ##

package com.wslook.algorithm.radix;
    
    public class IntToHexString {
        public static void main(String[] args) {
            int a = 23422;
            String str;
            System.out.println("======================使用自己写的方法=============================");
            str = intToHexString(a);
            System.out.println(str);
    //        str = "ffffa482";
            System.out.println(hexStringToInt2(str));
            System.out.println("======================使用Integer中的方法=============================");
            str = Integer.toHexString(a);
            System.out.println(str);
    //        System.out.println(Integer.parseInt(binaryString, 16));    //只能转换正数，转换负数报错
            System.out.println(Integer.parseUnsignedInt(str, 16));
    
        }
    
        /**
         * int转十六进制字符串
         *
         * 算法一：先求出二进制字符串，再转换成十六进制字符串
         * @param num 整数
         */
        public static String intToHexString(int num){
            String binaryStr = IntToBinary.intToBinaryString(num);
    
            //二进制串转十六进制串
            int count = binaryStr.length();
            StringBuilder sb = new StringBuilder();
            String subStr;
            while (count > 0){
    
                if (count <= 4){
                    subStr = binaryStr.substring(0, count);
                }else {
                    subStr = binaryStr.substring(count - 4, count);
                }
    
                count -= 4;
                int c = IntToBinary.binaryStringToInt2(subStr);
                sb.append(trans(c));
    
            }
    
            return sb.reverse().toString();
    
        }
    
        /**
         * 整数转十六进制字符串
         * @param deci 小于16的正整数
         * @return
         */
        private static char trans(int deci){
            if (deci < 10){
                return (char) (deci + 48);
            }
    
    //        return (char) (deci + 55);  //转成大写A-F
            return (char) (deci + 87);  //转成小写a-f
        }
    
        /**
         * 十六进制字符串转int
         *
         * 算法一：每位数字* 2的n-1次方，并相加
         * @param str 十六进制字符串
         */
        public static int hexStringToInt(String str){
            int result = 0, rem = 0, _pow = 1;
            //正序遍历字符串
            for (int i = 0; i < str.length(); i++){
                char hex = str.charAt(i);
                if (hex >= '0' && hex <= '9'){
                    rem = hex - 48;     //转换成数字0-9
                }else if (hex >= 'a' && hex <= 'f'){
                    rem = hex - 87;     //转换成数字10-15，'a'= 97
                }else if (hex >= 'A' && hex <= 'F'){
                    rem = hex - 55;     //转换成数字10-15，'A'= 65
                }
    
                //使用位移，计算16的n-1次方-----【16的n次方 =  1 << 4n】
                _pow = (int) Math.pow(16, (str.length() - 1 - i));
    //            _pow = 1 << (4 * (str.length() -1 - i));
                result += rem * _pow;
            }
    
    //        //倒序遍历字符串
    //        for (int i = str.length() - 1; i >= 0; i--){
    //            char hex = str.charAt(i);
    //            if (hex >= '0' && hex <= '9'){
    //                rem = hex - 48;
    //            }else if (hex >= 'a' && hex <= 'f'){
    //                rem = hex - 87;
    //            }else if (hex >= 'A' && hex <= 'F'){
    //                rem = hex - 55;
    //            }
    //
    //            //使用位移，计算16的n-1次方-----【16的n次方 = 2 << (4n -1)】
    //            result += rem * _pow;
                _pow = (int) Math.pow(16, (str.length() - i));
    //            _pow = _pow << 4;
    //        }
           return result;
        }
    
        /**
         * 十六进制字符串转int
         *
         * 算法二：使用十六进制转十进制的逆运算：被除数 = 除数 * 商 + 余数
         * @param str 十六进制字符串
         */
        public static int hexStringToInt2(String str){
            int result =0, rem = 0, temp;
            for (int i = 0; i < str.length(); i++){
                char hex = str.charAt(i);
                if (hex >= '0' && hex <= '9'){
                    rem = hex - 48;     //转换成数字0-9
                }else if (hex >= 'a' && hex <= 'f'){
                    rem = hex - 87;     //转换成数字10-15，'a'= 97
                }else if (hex >= 'A' && hex <= 'F'){
                    rem = hex - 55;     //转换成数字10-15，'A'= 65
                }
                //使用十六进制转十进制的逆运算：被除数 = 除数 * 商 + 余数
                result = result * 16 + rem;
            }
           return result;
        }
    }

转载于:https://www.cnblogs.com/wslook/p/9385415.html