Ⅰ. 乘法運算

為什麼先說乘法運算——因為我先做了乘法運算。其實思路也是很多的，但是最終我參考了網路上的一種計算方案，然後做了很多的修改。感覺這個在思路上應該是比較簡單的。

簡單點說：把數拆分成整數小數分別進行乘法運算，然後將結果放入一個特定長度的陣列中，在放入是要計算存放的偏移位置，最後再對這個進行處理（進位、標記等），得到最終的結果。

是不是有點暈。請我詳細說一下吧：

    首先還得把數都拆成整數+小數，然後採用的是（x1+x2）（y1+y2）=x1y1+x1y2+x2y1+x2y2。這種方式來計算的，這樣來算，都變成了整數的運算了。要簡單很多。但是4個結果怎麼累加起來計算呢，這就是第二步。
    要申明一個int陣列，長度=整數長度和+小數長度和+1（小數點佔1位）。通過實驗，我們可以看到任意2個整數相乘結果都不會超過這2個數的長度和。
    人為計算乘法的時候就是按右向左一位一位的計算的（低位對齊），所以為了對齊低位，我們將整數和小數全部反轉，並且轉化為char陣列，方便運算。然後進行4次乘法。
    按位進行乘法運算，採用雙層for迴圈完成這個操作。這裡最為天才的idea就是——不進位。當然必須得弄清楚整數相乘放在陣列的哪些個位置、小數相乘存放的開始位置，以及整數和小數相乘結果存放的開始位置。
    處理結果集合，將>=10的做進位處理。
    這一步也是很有才的想法——對小數點位置進行標記，而不是直接替換成“.”（int陣列也不能直接設定(/ □ \)）。
    有了第6步的想法，就有了第7步的做法，處理整數部分頭部的0和小數部分末尾的0，都是無效數字，這裡同樣採用標記的方式來處理
    最後將結果集合進行反轉輸出，遇到小數點標記和無效0標記直接替換和跳過。

這就是基本的思路了。後面又再次基礎上加上了負數的判斷、數字格式的判斷等，自己看註釋就可以明白了。

程式碼如下：

        //標記為小數點
        private static final int DOT=-99;
        //標記為無效數字
        private static final int INVALID=-100;
     
        /**
         * 大數乘法
         *
         * @param a    第一個數
         * @param b    第二個數
         * @return    最終結果
         */
        public static String multiply(String a, String b){
            //檢查數字格式
            checkNum(a);
            checkNum(b);
     
            //標記最終結果是否為負值
            boolean minus=false;
     
            //判斷是否有帶著-號
            if(a.startsWith("-") || b.startsWith("-")){
                //判斷是否全帶著-號
                if(a.startsWith("-") && b.startsWith("-")){
                }else{
                    //只有1個帶著-號，則結果為負值
                    minus=true;
                }
                if(a.startsWith("-")){
                    a = a.substring(1);
                }
                if(b.startsWith("-")){
                    b = b.substring(1);
                }
            }
     
            //獲取a,b的整數和小數部分
            String a_int = getInt(a);
            String a_fraction = getFraction(a);
            String b_int = getInt(b);
            String b_fraction = getFraction(b);
     
            //計算小數部分的總長度
            int len_fraction = a_fraction.length() +b_fraction.length() ;
     
            //a,b兩個數乘積的最大位數不會超過總位數之和+小數點（1位）
            int len = len_fraction +a_int.length()+b_int.length()+1;
     
            //建立結果陣列
            int[] result = new int[len];//預設全為0
     
            //為了方便計算，去掉小數點（最後在結果中加上小數點）
            //並將高低位對調(反轉是為了低位對齊)，最終轉化為char陣列
            char[] s_a_int = reverseStr(a_int);
            char[] s_a_fraction = reverseStr(a_fraction);
            char[] s_b_int = reverseStr(b_int);
            char[] s_b_fraction = reverseStr(b_fraction);
     
            //將a、b都拆分成整數+小數，然後
            //採用（x1+x2）（y1+y2）=x1y1+x1y2+x2y1+x2y2公式，分別計算乘積
            multiply(s_a_int, s_b_int, len_fraction, result);
            multiply(s_a_int, s_b_fraction, (len_fraction-s_b_fraction.length), result);
            multiply(s_b_int, s_a_fraction, (len_fraction-s_a_fraction.length), result);
            multiply(s_a_fraction, s_b_fraction, 0, result);
     
            // 處理結果集合，如果是大於10的就向前一位進位，本身進行除10取餘
            accumulateResultArrays(result);
     
            //標記小數點位置
            markDot(len_fraction, result);
     
            //切掉無用的0
            cutUnusedZero(len_fraction, result);
     
            //然後將資料反轉
            return (minus?"-":"") + reverseResult(result);
        }
     
        /**
         * 反轉字串，並轉化為陣列
         *
         * @param s        原字串
         * @return
         */
        private static char[] reverseStr(String s) {
            return new StringBuffer(s).reverse().toString().toCharArray();
        }
     
        /**
         * 計算2個數的每一位的乘積，放入到對應的結果陣列中（未進位）
         *
         * @param a    第一個數
         * @param b    第二個數
         * @param start    開始放入的偏移位置
         * @param result    結果陣列
         */
        private static void multiply(char[] a, char[] b, int start , int[] result){
            // 計算結果集合
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < b.length; j++) {
                    result[i + j + start] += (int) (a[i] - '0') * (int) (b[j] - '0');
                }
            }
        }
     
        /**
         * 累加每一位，超過10則然後進位
         *
         * @param result    結果陣列
         */
        private static void accumulateResultArrays(int[] result) {
            for (int i = 0; i < result.length; i++) {
                if (result[i] >= 10) {
                    result[i + 1] += result[i] / 10;
                    result[i] %= 10;
                }
            }
        }
     
        /**
         * 標記小數點位置
         *
         * @param len_fraction    小數長度
         * @param result    結果陣列（反轉的）
         */
        private static void markDot(int len_fraction, int[] result) {
            if(len_fraction>0){
                //標記小數點位置
                for (int i = result.length-1 ; i > len_fraction; i--) {
                    result[i] = result[i-1];
                }
                result[len_fraction]=DOT;//標記小數點位置
            }
        }
     
        /**
         * 去掉不必要的0（包括整數最前面的和小數最後面的0）
         *
         * @param len_fraction    小數長度
         * @param result        結果陣列
         */
        private static void cutUnusedZero(int len_fraction, int[] result) {
            //去掉小數部分不必要的0
            boolean flag_0_fraction = true;//標記一直是0
            for (int i =0; i< len_fraction; i++) {
                if(flag_0_fraction && result[i]==0){
                    result[i]=INVALID;//為0時標記為無效
                }else{
                    flag_0_fraction=false;
                    break;
                }
            }
     
            //去掉整數部分的0
            boolean flag_0_int=true;
            for (int i =result.length-1; i > len_fraction || (len_fraction==0 && i==0); i--) {
                if(flag_0_int && result[i]==0){
                    result[i]=INVALID;//為0時標記為無效
                }else{
                    flag_0_int=false;//遇到不為0時，停止。
                    break;
                }
            }
            if(flag_0_int){//整數部分全為0
                result[len_fraction+1]=0;
                if(flag_0_fraction){//同時，小數部分也全為0
                    result[len_fraction]=INVALID;//不需要小數點了，所以置為無效
                }
            }else{//整數部分不為0
                if(flag_0_fraction && len_fraction>0){//小數部分全為0
                    result[len_fraction]=INVALID;//不需要小數點了，所以置為無效
                }
            }
        }
     
        /**
         * 反轉結果，替換小數點，跳過無效的0
         *
         * @param result        結果陣列
         * @return
         */
        private static String reverseResult(int[] result) {
            //反轉
            StringBuffer sb = new StringBuffer();
            for (int i = result.length - 1; i >= 0; i--) {
                if(result[i]>INVALID){
                    sb.append(result[i]==DOT ? "." : result[i]);
                }
            }
            return sb.toString();
        }
 

我們繼續說第二個。
Ⅱ. 加法運算

有了上面的思路做鋪墊，下面的加法和減法基本上都可以秒懂了。負數及數字格式的判斷就直接略過了。直接說最基本的思路。

    前兩步同乘法運算。拆分整數+小數，宣告一個int陣列存放結果。長度為a b整數最大的長度+1+小數最大長度+1（小數點位）。因為加法最多位數比最大長度大1，所以有一個+1。
    結果是整數和+小數和，整數要低位對齊，所以要反轉，小數則不用反轉。
    用一個for迴圈來計算2個整數或者小數的和，同樣不進位。
    剩下的同乘法4-8步。

程式碼放在最後看吧。接著來說說減法。
Ⅲ. 減法運算

其實減法跟加法在程式碼上看，更類似。詳細說一下：（忽略負數及數字格式的判斷）

    前三步同加法運算。拆分整數+小數，宣告一個int陣列存放結果。長度為a b整數最大的長度+小數最大長度+1（小數點位）。結果是整數差+小數差。
    還是用一個for迴圈計算2個數的差，這裡不是不進位了，而是不借位。
    處理結果結合跟加法和乘法不一樣，加法和乘法都是進位，這裡是借位，所以處理不太一樣。
    剩下同加法。

具體程式碼如下：

        /**
         * 大數加法
         *
         * @param a    第一個數
         * @param b    第二個數
         * @return    最終結果
         */
        public static String add(String a, String b){
            //檢查數字格式
            checkNum(a);
            checkNum(b);
     
            //標記最終結果是否為負值
            boolean minus=false;
     
            //判斷是否有帶著-號
            if(a.startsWith("-") || b.startsWith("-")){
                //判斷是否全帶著-號
                if(a.startsWith("-") && b.startsWith("-")){
                    //2個都帶著-號，結果肯定為負值
                    minus=true;
                    if(a.startsWith("-")){
                        a = a.substring(1);
                    }
                    if(b.startsWith("-")){
                        b = b.substring(1);
                    }
                }else{
                    //如果只有一個是負值，則呼叫減法來完成操作
                    if(a.startsWith("-")){//a是負數
                        a = a.substring(1);
                        return subduct(b, a);
                    }else{
                        b = b.substring(1);
                        return subduct(a, b);
                    }
     
                }
            }
     
            //獲取a,b的整數和小數部分
            String a_int = getInt(a);
            String a_fraction = getFraction(a);
            String b_int = getInt(b);
            String b_fraction = getFraction(b);
     
            //計算小數部分最大長度
            int len_fraction = Math.max(a_fraction.length(), b_fraction.length());
     
            //計算整數部分最大長度
            int len_int = Math.max(a_int.length(), b_int.length())+1;
     
            //a,b兩個數整數最大長度和小數最大長度之和+小數點（1位）
            int len = len_fraction + len_int+1;
     
            //建立結果陣列
            int[] result = new int[len];//預設全為0
     
            //為了方便計算，去掉小數點（最後在結果中加上小數點）
            //將【整數部分】高低位對調(反轉是為了低位對齊)，最終轉化為char陣列
            //小數部分不用調整
            char[] s_a_int = reverseStr(a_int);
            char[] s_b_int = reverseStr(b_int);
            char[] s_a_fraction = a_fraction.toCharArray();
            char[] s_b_fraction = b_fraction.toCharArray();
     
            //採用整數+整數，小數+小數的方式運算
            add(s_a_int, s_b_int, len_fraction, result);
            add(s_a_fraction, s_b_fraction, 1-len_fraction, result);
     
            // 處理結果集合，如果是大於10的就向前一位進位，本身進行除10取餘
            accumulateResultArrays(result);
     
            //標記小數點位置
            markDot(len_fraction, result);
     
            //切掉無用的0
            cutUnusedZero(len_fraction, result);
     
            //然後將資料反轉
            return (minus ? "-" : "")+reverseResult(result);
        }
     
        /**
         * 計算2個數的每一位的和，放入到對應的結果陣列中（未進位）
         *
         * @param a    第一個數
         * @param b    第二個數
         * @param start    開始放入的偏移位置
         * @param result    結果陣列
         */
        private static void add(char[] a, char[] b, int start , int[] result){
            char[] c=null;
            //保證a是位數多的，如果b長度大於a，則交換a，b
            if(b.length>a.length){
                c=a;
                a=b;
                b=c;
            }
            // 計算結果集合，a的位數>=b的位數
            int i = 0, j=0;
            for (; i < a.length && j< b.length; i++,j++) {
                result[Math.abs(i + start)] += (int) (a[i] - '0') + (int) (b[j] - '0');
            }
            //如果a沒有處理完畢，直接把a剩下的值賦值給結果陣列即可
            for (; i < a.length; i++) {
                result[Math.abs(i + start)] += (int) (a[i] - '0');
            }
            if(c!=null){//如果交換過，則再交換回來
                c=a;
                a=b;
                b=c;
            }
            c=null;
        }
     
        /**
         * 大數減法
         *
         * @param a    第一個數
         * @param b    第二個數
         * @return    最終結果
         */
        public static String subduct(String a, String b){
            //檢查數字格式
            checkNum(a);
            checkNum(b);
     
            //標記最終結果是否為負值
            boolean minus=false;
     
            //判斷是否有帶著-號
            if(a.startsWith("-") || b.startsWith("-")){
                //判斷是否全帶著-號
                if(a.startsWith("-") && b.startsWith("-")){
                    //2個都帶著-號
                    if(a.startsWith("-")){
                        a = a.substring(1);
                    }
                    if(b.startsWith("-")){
                        b = b.substring(1);
                    }
                    return subduct(b, a);
                }else{
                    //如果只有一個是負值，則呼叫加法來完成操作
                    if(a.startsWith("-")){//a是負值，b是非負值
                        return add(a, "-"+b);//2個負值的加法運算
                    }else{//b是負值
                        b = b.substring(1);
                        return add(a, b);//2個正值的加法運算
                    }
                }
            }
     
            //獲取a,b的整數和小數部分
            String a_int = getInt(a);
            String a_fraction = getFraction(a);
            String b_int = getInt(b);
            String b_fraction = getFraction(b);
     
            boolean isSame = false;
            //判斷大小
            if(b_int.length()>a_int.length()){
                //如果b>a
                return "-"+subduct(b, a);
            }else if(b_int.length()==a_int.length()){
                char[] s_a = a_int.toCharArray();
                char[] s_b = b_int.toCharArray();
                for (int i = 0; i < s_a.length; i++) {
                    if(s_b[i]>s_a[i]){
                        minus=true;
                        isSame=false;
                        break;
                    }else if(s_b[i]<s_a[i]){
                        isSame=false;
                        break;
                    }else{
                        isSame = true;
                    }
                }
                if(isSame){//整數部分全部相同，對比小數部分
                    s_a = a_fraction.toCharArray();
                    s_b = b_fraction.toCharArray();
                    for (int i = 0; i < Math.min(s_a.length, s_b.length); i++) {
                        if(s_b[i]>s_a[i]){
                            minus=true;
                            isSame=false;
                            break;
                        }else if(s_b[i]<s_a[i]){
                            isSame=false;
                            break;
                        }else{
                            isSame = true;
                        }
                    }
                    if(isSame){//前部分全相同
                        if(s_b.length>s_a.length){//前部分全相同，b小數位數多,則 b>a
                            return "-"+subduct(b, a);
                        }else if(s_b.length == s_a.length){
                            return "0";
                        }
                    }else if(minus){//如果b>a
                        return "-"+subduct(b, a);
                    }
                }
            }
     
     
            //計算小數部分最大長度
            int len_fraction = Math.max(a_fraction.length(), b_fraction.length());
     
            //計算整數部分最大長度
            int len_int = Math.max(a_int.length(), b_int.length());
     
            //a,b兩個數整數最大長度和小數最大長度之和+小數點（1位）
            int len = len_fraction + len_int+1;
     
            //建立結果陣列
            int[] result = new int[len];//預設全為0
     
            //為了方便計算，去掉小數點（最後在結果中加上小數點）
            //將【整數部分】高低位對調(反轉是為了低位對齊)，最終轉化為char陣列
            //小數部分不用調整
            char[] s_a_int = reverseStr(a_int);
            char[] s_b_int = reverseStr(b_int);
            char[] s_a_fraction = a_fraction.toCharArray();
            char[] s_b_fraction = b_fraction.toCharArray();
     
            //採用整數+整數，小數+小數的方式運算
            subduct(s_a_int, s_b_int, len_fraction, result);
            subduct(s_a_fraction, s_b_fraction, 1-len_fraction, result);
     
            // 處理結果集合，如果是大於10的就向前一位進位，本身進行除10取餘
            subductResultArrays(result);
     
            //標記小數點位置
            markDot(len_fraction, result);
     
            //切掉無用的0
            cutUnusedZero(len_fraction, result);
     
            //然後將資料反轉
            return (minus ? "-" : "")+reverseResult(result);
        }
     
        /**
         * 計算2個數的每一位的差，放入到對應的結果陣列中（未進位）
         *
         * @param a    第一個數
         * @param b    第二個數
         * @param start    開始放入的偏移位置
         * @param result    結果陣列
         */
        private static void subduct(char[] a, char[] b, int start , int[] result){
            // 計算結果集合，a的位數>=b的位數
            int i = 0, j=0;
            for (; i < a.length && j< b.length; i++,j++) {
                result[Math.abs(i + start)] +=((int) (a[i] - '0') - (int) (b[j] - '0'));
            }
            //如果a沒有處理完畢，直接把a剩下的值賦值給結果陣列即可
            for (; i < a.length; i++) {
                result[Math.abs(i + start)] +=((int) (a[i] - '0'));
            }
            //如果a沒有處理完畢，直接把a剩下的值賦值給結果陣列即可
            for (; i < b.length; i++) {
                result[Math.abs(i + start)] +=-((int) (b[i] - '0'));
            }
        }
     
        /**
         * 檢查每一位，小於0（不含標記的小數點未和無效的0）則然後向高位借位。
         *
         * @param result    結果陣列
         */
        private static void subductResultArrays(int[] result) {
            for (int i = 0; i < result.length-1; i++) {
                if (result[i] < 0 && result[i]>DOT) {
                    result[i + 1]--;
                    result[i] += 10;
                }
            }
        }

寫個main方法測試一下吧：

        public static void main(String[] args) {
            String a = "9213213210.4508";
            String b = "12323245512512100.4500081";
            String r = multiply(a, b);
            System.out.println(a+"*"+b+"="+r);
            String r1 = add(a, b);
            System.out.println(a+"+"+b+"="+r1);
            String r2 = subduct(a, b);
            System.out.println(a+"-"+b+"="+r2);
        }

測試結果如下：