进制转换，大数相加

一、十进制小数转二进制，二进制转十进制

二进制转十进制： 对二进制从后往前数第i位上的数进行乘以2的i-1 次方；

十进制小数转二进制：

1. 整数部分利用短除法原理，用要转换为二进制的十进制数每次除2取余，再逆序输出，求得结果。
2. 小数部分利用乘法的方式，每次乘2，取整数部分记下，正序输出，求得结果。

package zsh;

import java.util.Scanner;

public class Decimal2Binary {
    private static final int N = 7;// 保留到小数点后7位

    private static StringBuilder resultInteger = new StringBuilder("");// 保存整数部分的计算结果
    private static StringBuilder resultDecimal = new StringBuilder("");// 保存小数部分的计算结果

    // 为了便于计算，使用integer和decimal分别保存原始数据的整数和小说部分。
    private static int integer = 0;
    private static double decimal = 0;

    // 计算整数部分
    private static void calculateInteger(int integer) {
        while (integer != 0) {
            resultInteger.append(integer % 2);
            integer = integer >> 1;
        }
        resultInteger.reverse();
        System.out.print(resultInteger);
    }

    // 计算小数部分的实现
    private static void calculateDecimal(double decimal) {
        int i = 1;
        while ((decimal = decimal * 2) != 0){
            if (decimal >= 1) {
                resultDecimal.append("1");
                decimal--;
            } else {
                resultDecimal.append("0");
            }
            i++;
            if (i == N) //精度设置
                break;
        }
        System.out.print("." + resultDecimal);
    }

    /**
     * 将二进制转换为10进制
     * @param bi ：待转换的二进制
     * @return
     */
    public  static  Integer Biannary2Decimal(int bi){
        String binStr = bi+"";
        Integer sum = 0;
        int len = binStr.length();
        for (int i=1;i<=len;i++){
            //第i位 的数字为：
            int dt = Integer.parseInt(binStr.substring(i-1,i));
            sum+=(int)Math.pow(2,len-i)*dt;
        }
        return  sum;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        //清空结果保存变量中的数据
        resultInteger.delete(0, resultInteger.length());
        resultDecimal.delete(0, resultDecimal.length());

        System.out.print("请输入一个十进制数：");

        decimal = scan.nextDouble();// 从控制台获取数据
        integer = (int) decimal;
        decimal = decimal - integer;

        // 为了方便观察，添加小数点
        System.out.print("换算为二进制为：");

        if (integer != 0) {
            calculateInteger(integer);// 整数，计算结果并输出
        } else {
            resultInteger.append("0");
            System.out.print(resultInteger);
        }

        if (decimal != 0) {
            // 有小数部分
            calculateDecimal(decimal);// 小数，计算结果并输出
        }
        System.out.println();
        System.out.println("二进制转十进制");
        System.out.println(Biannary2Decimal(1001));
    }
}

二、大数相加

package zsh;

import java.math.BigInteger;

/**
 * 题目：
 * 两个大数相加
 *
 * 题目描述：
 *
 两个大数相加。
 1、是整数；
 2、两个数无限大，long都装不下；
 3、不能用BigInteger；
 4、不能用任何包装类提供的运算方法；
 5、两个数都是以字符串的方式提供。
 *
 */
public class BigIntegerAdd {

    /**
     * 思路：
     * 字符串逐位相加，需要进位则进位处理，考虑两个问题：
     * 1、char怎么转换为integer, 减去'0'即可
     * 2、怎么处理对应位相加?反转字符串相加，正确处理进位即可，
     *    这样个位对应个位，十位对应十位，剩余的直接追加
     */
    public String add(String str1, String str2) {
        // 一个字符串为空 直接返回另外一个
        if (str1 == null || "".equals(str1)) {
            return str2;
        }
        if (str2 == null || "".equals(str2)) {
            return str1;
        }

        StringBuilder sb = new StringBuilder();

        // 字符串都不为空时
        char[] arr1 = str1.toCharArray();
        char[] arr2 = str2.toCharArray();
        int idx1 = arr1.length - 1;
        int idx2 = arr2.length - 1;

        // 缓存是否需要进位
        boolean carry = false;
        // 遍历两个字符串 处理元素相加
        while (idx1>=0 && idx2 >=0) {
            char cur1 = arr1[idx1];
            char cur2 = arr2[idx2];
            // 相加
            int sum = cur1 - '0' + cur2 - '0';
            // 上一次运算是否有进位
            sum = carry ? sum+1: sum;
            // 是否需要进位
            carry = sum >= 10 ? true : false;
            // 相加结果 取个位数->字符类型
            sb.append((char)((sum%10) + '0'));
            // 索引递减
            idx1--;
            idx2--;
        }

        // 处理剩余的元素
        while (carry || idx1 >= 0 || idx2 >= 0) {
            if (idx1 >= 0) {
                // 当前元素处理
                int sum = arr1[idx1] - '0' + (carry ? 1 : 0);
                // 下次是否需要进位
                carry = sum >= 10 ? true : false;
                // 添加到结果
                sb.append((char)((sum%10) + '0'));
                idx1--;
            } else if (idx2 >= 0) {
                // 当前元素处理
                int sum = arr2[idx2] - '0' + (carry ? 1 : 0);
                // 下次是否需要进位
                carry = sum >= 10 ? true : false;
                // 添加到结果
                sb.append((char)((sum%10) + '0'));
                idx2--;
            } else {
                sb.append('1');
                carry = false;
            }
        }

        // 反转sb 后返回
        return sb.reverse().toString();
    }

    public static void main(String[] args) {
        String str1 = "111111119111111111";
        String str2 = "12";
        System.out.println(new BigIntegerAdd().add(str1, str2));
        System.out.println(new BigInteger(str1).add(new BigInteger(str2)));

        String str3 = "999928";
        String str4 = "72";
        System.out.println(new BigIntegerAdd().add(str3, str4));
        System.out.println(new BigInteger(str3).add(new BigInteger(str4)));
    }

}