大數(shù)相乘

假設有A和B兩個大數(shù)，位數(shù)分別為a和b。根據(jù)我們平常手動計算乘法的方式可以看出，最終的結果的位數(shù)c一定小于等于a+b，我們可以舉一個簡單的例子來說明，99999=98901，最終結果是五位（a+b）。下面我們根據(jù)98765 = 74970來看看結果中的每一位是怎么得來的，最后一位0是A的最后一位8和B的最后一位5的乘機除10取余得到的，結果的倒數(shù)第二位7是A的倒數(shù)第二位9和B的最后一位5的乘積45與A的最后一位8和B的倒數(shù)第二位6的乘積48之和93然后加上上一位的進位4得到97然后在除10取余得到的7……依次進行下去就可以得到最終結果。

下面來總結一下規(guī)律：

A中的第i位與B的第j位之積最終會存放到結果的第i+j位中（i和j都是從后往前數(shù)），所以我們可以先進行結果中每一位的計算，完成所有計算后在進行進位的計算。為了將i和j從0開始計算，我們先將字符串A和B進行逆轉(zhuǎn)，然后在進行計算的時候就可以從0開始了。具體程序如下：

public static void bigNumberSimpleMulti(String f, String s) {  
        System.out.print("乘法：\n" + f + "*" + s + "=");  
        // 獲取首字符，判斷是否是符號位  
        char signA = f.charAt(0);  
        char signB = s.charAt(0);  
        char sign = '+';  
        if (signA == '+' || signA == '-') {  
            sign = signA;  
            f = f.substring(1);  
        }  
        if (signB == '+' || signB == '-') {  
            if (sign == signB) {  
                sign = '+';  
            } else {  
                sign = '-';  
            }  
            s = s.substring(1);  
        }  
        // 將大數(shù)翻轉(zhuǎn)并轉(zhuǎn)換成字符數(shù)組  
        char[] a = new StringBuilder(f).reverse().toString().toCharArray();  
        char[] b = new StringBuilder(s).reverse().toString().toCharArray();  
        int lenA = a.length;  
        int lenB = b.length;  
        // 計算最終的最大長度  
        int len = lenA + lenB;  
        int[] result = new int[len];  
        // 計算結果集合  
        for (int i = 0; i < a.length; i++) {  
            for (int j = 0; j < b.length; j++) {  
                result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');  
            }  
        }  
        // 處理結果集合，如果是大于10的就向前一位進位，本身進行除10取余  
        for (int i = 0; i < result.length; i++) {  
            if (result[i] > 10) {  
                result[i + 1] += result[i] / 10;  
                result[i] %= 10;  
            }  
        }  
        StringBuffer sb = new StringBuffer();  
        // 該字段用于標識是否有前置0，如果是0就不需要打印或者存儲下來  
        boolean flag = true;  
        for (int i = len - 1; i >= 0; i--) {  
            if (result[i] == 0 && flag) {  
                continue;  
            } else {  
                flag = false;  
            }  
            sb.append(result[i]);  
        }  
        if (!sb.toString().equals("")) {  
            if (sign == '-') {  
                sb.insert(0, sign);  
            }  
        } else {  
            sb.append(0);  
        }  
        // 返回最終結果  
        System.out.println(sb.toString());  
    }  

大數(shù)相加

和相乘是類似的，不同的地方只是result結果集的長度，其值為較長字符串的長度加一。具體代碼如下：

public String bigNumberAdd(String f, String s) {  
        //翻轉(zhuǎn)兩個字符串，并轉(zhuǎn)換成數(shù)組  
        char[] a = new StringBuilder(f).reverse().toString().toCharArray();  
        char[] b = new StringBuilder(s).reverse().toString().toCharArray();  
        int lenA = a.length;  
        int lenB = b.length;  
        //計算兩個長字符串中的較長字符串的長度  
        int len = lenA > lenB ? lenA : lenB;  
        int[] result = new int[len + 1];  
        for (int i = 0; i < len + 1; i++) {  
            //如果當前的i超過了其中的一個，就用0代替，和另一個字符數(shù)組中的數(shù)字相加  
            int aint = i < lenA ? (a[i] - '0') : 0;  
            int bint = i < lenB ? (b[i] - '0') : 0;  
            result[i] = aint + bint;  
        }  
        //處理結果集合，如果大于10的就向前一位進位，本身進行除10取余  
        for (int i = 0; i < result.length; i++) {  
            if (result[i] > 10) {  
                result[i + 1] += result[i] / 10;  
                result[i] %= 10;  
            }  
        }  
        StringBuilder sb = new StringBuilder();  
        //該字段用于標識是否有前置0，如果有就不要存儲  
        boolean flag = true;  
        for (int i = len; i >= 0; i--) {  
            if (result[i] == 0 && flag) {  
                continue;  
            } else {  
                flag = false;  
            }  
            sb.append(result[i]);  
        }  
        return sb.toString();  
    }  

大數(shù)相減

大數(shù)相減和大數(shù)相加類似，只是需要判斷正負。

public static String bigNumberSub(String f, String s) {  
        System.out.print("減法:" + f + "-" + s + "=");  
        // 將字符串翻轉(zhuǎn)并轉(zhuǎn)換成字符數(shù)組  
        char[] a = new StringBuilder(f).reverse().toString().toCharArray();  
        char[] b = new StringBuilder(s).reverse().toString().toCharArray();  
        int lenA = a.length;  
        int lenB = b.length;  
        // 找到最大長度  
        int len = lenA > lenB ? lenA : lenB;  
        int[] result = new int[len];  
        // 表示結果的正負  
        char sign = '+';  
        // 判斷最終結果的正負  
        if (lenA < lenB) {  
            sign = '-';  
        } else if (lenA == lenB) {  
            int i = lenA - 1;  
            while (i > 0 && a[i] == b[i]) {  
                i--;  
            }  
            if (a[i] < b[i]) {  
                sign = '-';  
            }  
        }  
        // 計算結果集，如果最終結果為正，那么就a-b否則的話就b-a  
        for (int i = 0; i < len; i++) {  
            int aint = i < lenA ? (a[i] - '0') : 0;  
            int bint = i < lenB ? (b[i] - '0') : 0;  
            if (sign == '+') {  
                result[i] = aint - bint;  
            } else {  
                result[i] = bint - aint;  
            }  
        }  
        // 如果結果集合中的某一位小于零，那么就向前一位借一，然后將本位加上10。其實就相當于借位做減法  
        for (int i = 0; i < result.length - 1; i++) {  
            if (result[i] < 0) {  
                result[i + 1] -= 1;  
                result[i] += 10;  
            }  
        }  
  
        StringBuilder sb = new StringBuilder();  
        // 如果最終結果為負值，就將負號放在最前面，正號則不需要  
        if (sign == '-') {  
            sb.append('-');  
        }  
        // 判斷是否有前置0  
        boolean flag = true;  
        for (int i = len - 1; i >= 0; i--) {  
            if (result[i] == 0 && flag) {  
                continue;  
            } else {  
                flag = false;  
            }  
            sb.append(result[i]);  
        }  
        // 如果最終結果集合中沒有值，就說明是兩值相等，最終返回0  
        if (sb.toString().equals("")) {  
            sb.append("0");  
        }  
        // 返回值  
        System.out.println(sb.toString());  
        return sb.toString();  
    }