计算机基础原理之：十进制和二进制互转逻辑

最近在重温计算机基础原理这些基础信息，目前重温到不同进制的数据，做个记录。

• 10进制转2进制逻辑：
  • 
  • 01001111，这个是个8位的二进制数据，10进制的数据为：79，计算方法如下：
  • 从右到左算，有1的就加，为0的跳过 ： 2^6 + 2^3 + 2^2  + 2^1 + 2^0 = 79
• 2进制转10进制逻辑：
  • 　　十进制数 123 ：
  •       (123 ÷ 2 = 61) 余 (1)
  •       (61 ÷ 2 = 30) 余 (1)
  •       (30 ÷ 2 = 15) 余 (0)
  •       (15 ÷ 2 = 7) 余 (1)
  •       (7 ÷ 2 = 3) 余 (1)
  •       (3 ÷ 2 = 1) 余 (1)
  •       (1 ÷ 2 = 0) 余 (1)

除到商为0就停止，可以理解成循环条件结束。

以上逻辑都可以拿代码中的循环和数组实现，逻辑代码很简单，一开始想用c来实现，但是写了一下很变扭，后面放弃了，主要是不太熟悉c。

最后还是用java来实现方便点，不用造轮子的快乐。😁😁😁

package com.oceanbase.test;
import java.util.ArrayList;
import java.util.Collections;

/**
 * @Auther: yuzj
 * @Date: 2024/7/23 - 07 - 23 - 7:39
 * @Description: org.test
 * @version: 1.0
 */
public class BinaryConversion {
    private static final ArrayList<Long> bitMapDecimalPom = new ArrayList<Long>();
    static {
        for (int i = 32-1; i >= 0; i--) {
            bitMapDecimalPom.add(new Double(Math.pow(2,i)).longValue());
        }
    }
    private static char[] bitStringToChar(String bit32string) throws Exception {
        char[] bit32charArray = bit32string.toCharArray();
        if (bit32string.length() > 32) {
            throw new Exception("bitStringToChar 函数传入的 bit32string 参数长度超过32位");
        }
        for (char c : bit32charArray){
            if (c != '0' && c != '1') {
                throw new Exception("bit32charArray 参数内容有0和1以外的数据");
            }
        }

        return bit32charArray;
    }

    // bitToDecimal方法主要作用是：2 进制转换成 10 进制
    private static Long bitToDecimal(String bit32string) throws Exception {

        Long DecimalNum = 0l;
        // 传进来的二进制字符串转换成 char 数组
        char[] bit32Chars = bitStringToChar(bit32string);
        // bit32CharsLength 为 bit32Chars 数组 的长度
        int bit32CharsLength = bit32Chars.length;
        for (int i = bitMapDecimalPom.size() -1 ; i >= 0; i--) {
            if (bit32Chars[bit32CharsLength-1] == '1'){
                DecimalNum = DecimalNum + bitMapDecimalPom.get(i);
            }
            // bit32Chars 从右到左偏移
            bit32CharsLength = bit32CharsLength - 1;

            // bit32Chars 从右到左偏移，索引到0就结束循环
            if (bit32CharsLength == 0){
                break;
            }
        }
        return DecimalNum;
    }


    // DecimalToBit：10 进制 换成 2 进制转
    private static String DecimalToBit(Integer Decimal32int) throws Exception {

        // 先定义一个数组
        ArrayList<String> DecimalArr = new ArrayList<String>();

        //这里逻辑 如果传入 123 就赋值到 DecimalModNum
        Integer DecimalModNum = Decimal32int;
        Integer modNum        = null;
        if (Decimal32int > Integer.MAX_VALUE ){
            throw new Exception("DecimalToBit 方法传入 bit32int 参数大于 2147483648");
        }

        // 如过DecimalModNum不等于0还继续循环
        while (DecimalModNum != 0){

            // DecimalModNum 假如是 123 ，然后就 123 对 2 取余 1 放到 modNum，然后把取余值丢入 DecimalArr
            modNum = DecimalModNum % 2 ;
            DecimalArr.add(modNum.toString());

            // 然后 123➗2 等于 61整数结果，继续拿结果来÷2，除到0为止。
            DecimalModNum = DecimalModNum /2 ;
        }

        // 将取余的值翻转
        Collections.reverse(DecimalArr);

        StringBuilder stringBuilder = new StringBuilder();


        for (String s :DecimalArr){
            stringBuilder.append(s);
        }

        return stringBuilder.toString();

    }

    public static void main(String[] args) throws Exception {
        // 10进制转换成2进制
        String bitNum = DecimalToBit(999);
        System.out.println("999 转换成2进制：" + bitNum);

        System.out.println("");

        // 2进制转换成10进制
        Long DecimalNum = bitToDecimal(bitNum);
        System.out.println("1111100111 转换成10进制：" + DecimalNum);


    }

}