计组（COA) Programming1: 整数和二进制补码、整数和NBCD码、浮点数(float)和二进制码（IEEE 754）的相互转换。_java nbcd to decical

1、整数转化为二进制补码。

public String intToBinary(String numStr) {
        //判断符号
        boolean isNeg = numStr.charAt(0) == '-';
        //去掉符号位
        if(isNeg) numStr = numStr.substring(1);
 
        int num = parseInt(numStr);
        StringBuffer binStr = new StringBuffer();
        while(binStr.length() != 32)
        {
            binStr.append(num % 2);
            num /= 2;
        }
        //如果是负数，进行取反加一，此处运用简便方法：从右数第一个‘1’开始，其前每一位取反
        //注意此处得到的binStr是反的
        if(isNeg)
        {
            int lastIdx = binStr.indexOf("1");
            for(int i = lastIdx + 1; i < binStr.length(); i++)
            {
                if(binStr.charAt(i) == '0') binStr.setCharAt(i,'1');
                else binStr.setCharAt(i,'0');
            }
        }
 
        return binStr.reverse().toString();
    }

2、二进制补码转化为整数。

public String binaryToInt(String binStr) {
 
        StringBuffer buffer = new StringBuffer(binStr);
        //判断符号
        boolean isNeg = buffer.charAt(0) == '1';
        //若是负数，先进行转化
        //此处同样运用简便方法
        int index = buffer.lastIndexOf("1");
        if(isNeg)
            for(int i = 1; i < index; ++i)
            {
                if(buffer.charAt(i) == '0') buffer.setCharAt(i,'1');
                else buffer.setCharAt(i,'0');
            }
 
        int sum = 0;
        for(int i = 1; i < buffer.length(); i++) {
            sum += (buffer.charAt(i) - '0') * Math.pow(2, buffer.length() - 1 - i);
        }
 
        if(isNeg) sum = -1 * sum;
 
        return (sum+"");
    }

3、NBCD码转化为整数

public String NBCDToDecimal(String NBCDStr) {
 
        //将符号位取出，“1100”为正，“1101”为负
        String sign = NBCDStr.substring(0,4);
 
        int sum = 0;
        for(int i = 4; i < NBCDStr.length() ; i += 4)
        {
            String subStr = NBCDStr.substring(i,i+4);
            sum = sum * 10 + Integer.parseInt(binaryToInt(subStr,4));
        }
 
        return (sign.equals("1100") ? sum + "" : "-" + sum);
    }

public String binaryToInt(String binStr, int bits)
{
        //bits 为binStr的位数
        //将binStr转化为无符号整数
        int sum = 0;
        for(int i = 0; i < binStr.length(); i++)
        {
            sum += (binStr.charAt(i) - '0') * Math.pow(2,bits - 1 - i);
        }
        return (sum+"");
}

 

4、整数转化为NBCD码

public String decimalToNBCD(String decimalStr) {
        //TODO:
        StringBuffer binStr = new StringBuffer();
 
        //判断正负
        if(decimalStr.charAt(0) == '-') {
            binStr.append("1101");
            decimalStr = decimalStr.substring(1);
        }
        else binStr.append("1100");
 
        //如果位数不够，补'0'
        for(int j = 0; j < 7 - decimalStr.length(); j++) binStr.append("0000");
 
        //计算
        for(int i = 0; i < decimalStr.length(); i++){
            binStr.append(intToBinary(decimalStr.substring(i,i+1),4));
        }
        return binStr.toString();
    }

public StringBuffer intToBinary(String numStr, int bits)
    {
        //bits为要转化的二进制数的位数
        //功能为将某个整数转化为指定位数的二进制码
        int num = Integer.parseInt(numStr);
        StringBuffer binStr = new StringBuffer();
        while(binStr.length() != bits)
        {
            binStr.append(num % 2);
            num /= 2;
        }
        return binStr.reverse();
    }

 

5、浮点数转化为二进制数

public String floatToBinary(String floatStr) {
        
        float num = Float.parseFloat(floatStr);
        //为零
        if(num == 0.0) return "00000000000000000000000000000000";
        else if(num == -0.0) return "10000000000000000000000000000000";
 
        //无穷
        else if(num >= Math.pow(2,128)) return "+Inf";
        else if(num <= -1 * Math.pow(2,128)) return "-Inf";
 
 
        StringBuffer res = new StringBuffer();
        //符号位
        if(num < 0.0) res.append('1');
        else res.append('0');
 
        num = Math.abs(num);
        //非规格化数
        if(num > 0.0 && num < Math.pow(2,-126))
        {
            res.append("00000000");
            //得到0.bbbb...形式的小数
            num *= Math.pow(2,126);
            res.append(signToBinary(num));
            //补‘0’
            while(res.length() < 32) res.append("0");
            return res.toString();
        }
 
        //规格化数
        for(int i = -126; i <= 127; i++)
        {
            if(num >= Math.pow(2,i) && num < Math.pow(2,i+1))
            {
                //i+127： 127为偏置常数
                res.append(intToBinary((i+127)+"",8));
                //得到1.bbbbb...形式的小数
                num *= Math.pow(2,-1 * i);
                res.append(signToBinary(num - 1));
                //位数小于32，补零
                while(res.length() < 32) res.append("0");
                return res.toString();
            }
        }
        return "";
    }

public String signToBinary(float num)
    {
        //函数功能为将小数转化为二进制数
        StringBuffer res = new StringBuffer();
        while(num != 0.0)
        {
            num *= 2;
            if(num >= 1)
            {
                res.append('1');
                num -= 1;
            }
            else res.append('0');
        }
        return res.toString();
    }

public StringBuffer intToBinary(String numStr, int bits)
    {
        int num = Integer.parseInt(numStr);
        StringBuffer binStr = new StringBuffer();
        while(binStr.length() != bits)
        {
            binStr.append(num % 2);
            num /= 2;
        }
        return binStr.reverse();
    }

6、二进制数转化为浮点数

public String binaryToFloat(String binStr) {
        //取出相应部分：符号位，阶码，小数
        char sign = binStr.charAt(0);
        String order = binStr.substring(1,9);
        String significant = binStr.substring(9);
 
        StringBuffer res = new StringBuffer(sign == '0' ? "" : "-");
 
        //阶码
        int trueOrderNum = 0;
        int OrderNum = Integer.parseInt(binaryToInt(order,8));
        //非规格化数
        if(OrderNum == 0) trueOrderNum = -126;
        //规格化数
        else if(OrderNum != 255) trueOrderNum = OrderNum - 127;
 
        //小数部分
        float num = binToSignificant(significant);
        //无穷
        if(num == 0 && OrderNum == 255) return (sign == '1') ? "-Inf" : "+Inf";
        //非数
        else if(num != 0 && OrderNum == 255)  return "NaN";
        //非规格化数隐藏位为0，规格化数隐藏位为1
        else if(OrderNum != 0) num += 1;
 
        res.append(num * Math.pow(2,trueOrderNum));
        return res.toString();
    }

public float binToSignificant(String binStr)
    {
        //二进制码转小数
        float res = 0;
        for(int i = 0; i < binStr.length(); i++) {
            res += (binStr.charAt(i) - '0') / Math.pow(2,(i+1));
        }
        return res;
    }

public String binaryToInt(String binStr, int bits)
    {
        int sum = 0;
        for(int i = 0; i < binStr.length(); i++)
        {
            sum += (binStr.charAt(i) - '0') * Math.pow(2,bits - 1 - i);
        }
        return (sum+"");
    }