文字列解析と減算演算子（BIgIntergeを使用していない）の方法、私が見るのを助けるためにトラブル

今日の加算と減算の文字列を書く（BIgIntergeを使用しない）方法、あなたは私が問題かどうかを見るのを助けるトラブル：

パブリック クラスStringCalculator {
     公共 静的 ボイドメイン（文字列[]引数）{
         // テスト 
        するSystem.out.println（parseStrAri（ "99 + 99 + 1~99 + = 1。" ））; 
    } 

    // 解析減算
    プライベート スタティックparseStrAriストリング（文字列DEST）{
         // オペレータアレイ 
        | - |（ "= \\ +"文字列は、[] = NUMS dest.split ）;
         // 算術符号
        のchar [] = dest.replaceAllのOPS（「[0-9] "" " ）.toCharArray（）;
         // パラメータをチェックする
        IF（nums.length == 0 || ops.length == 0 ）{
             スロー 新新IllegalArgumentException（ "間違った入力パラメータは、式を満たしていない" ）; 
        } 
        int型 numIndex = 0 ; 
        文字列結果 = NUMS [0 ;]
         のための（チャー：OPS C）{
             スイッチ（C）{
                 ケース '+' ：
                     // -結果+ Bに従って- （AB）20000扱わ-1000+ 
                    IF（ " - "に等しいが（result.substring（0.1。 ）））{ 
                        文字列NUMA =   EXPUNGE（結果）; 
                        文字列NUMB = NUMS [++ numIndex]。
                         IF （isLeftBig（NUMA、NUMB））{
                            結果 = subtractionStr（NUMA、無感覚）。
                            結果 =「 - 」+ 結果。
                        } 他{ 
                            結果 = subtractionStr（無感覚、NUMA）。
                        } 
                    } 他{ 
                        結果 = additionStr（その結果、NUMS [++ numIndex]）。
                    } 
                    ブレーク;
                ケース ' - ' ：
                    文字列麻痺 =のNUMS [++ numIndex]。
                    もし（ " - "は等しい（result.substring（0,1 ）））{ 
                        文字列NUMA = EXPUNGE（結果）。
                        結果 = additionStr（NUMA、無感覚）。
                        結果 =「 - 」+ 結果。
                    } 他{ 
                        文字列NUMA = 結果。
                        もし（isLeftBig（NUMA、無感覚））{ 
                            結果 = subtractionStr（NUMA、無感覚）。
                        } 他{ 
                            結果 =  subtractionStr（無感覚、NUMA）。
                            結果= " - " + 結果。
                        } 
                    } 
                    ブレーク。
                ケース「=」：
                     リターン結果; // 这里返回结果
                デフォルト：
                     // 無視
            } 
        } 

        戻り値の結果; 
    } 

    // 加法追加
    プライベート 静的文字additionStr（文字列、列B）{ 
        StringBuilderのビルダーが = 新規のStringBuilderを（）; 
        A =（a）の逆。
        B = 逆方向（B）。
        // 调换
        場合（a.length（）< てb.length（））{ 
            列C = B。
            B = A。= C。
        } 
        INTアレン= a.length（）。
        INT BLEN = てb.length（）。

        ブール ISOVER = 偽;
        以下のために（int型 i = 0; iはアレンを<; Iは++ ）{
             int型の結果= 0 。
            int型キャラ= a.charAt（I） - 48 ;
            もし（iは< BLENを）{
                 {int型シャルブ= b.charAt（I） - 48 ; 
                結果 =キャラ+ シャルブ。
            } 他{ 
                結果 =結果+ キャラ。
            } 
            // 进位
            場合（ISOVER）{ 
                結果 ++ 。
            } 
            場合（結果は> = 10 ）{ 
                builder.append（結果 - 10 ）; 
                ISOVER = 真; 
            } 他
                builder.append（結果）。
                ISOVER =偽; 
            } 
        } 
        もし（ISOVER）{ 
            builder.append（ "1" ）。
        } 
        戻り逆（builder.toString（））。
    } 

    // サブ减法
    プライベート 静的文字列subtractionStr（文字列、列B）{ 
        StringBuilderのビルダー = 新規のStringBuilder（）; = （a）の逆。
        B = 逆方向（B）。
        // 调换
        場合（a.length（）<のb.length（））{
             スロー 新しい、IllegalArgumentExceptionを（ "字符串有误"）; 
        } 

        INTアレン= a.length（）。
        INT BLEN = てb.length（）。
        バイト ISOVER = 0; //   借位

        のために（int型 ;私はアレンを<I ++は、I = 0 ）{
             int型の結果= 0 。
            int型キャラ= a.charAt（I） - 48 ; 
            結果 =結果+ ISOVER。
            ISOVER = 0 ;
            もし（iは< BLENを）{
                 int型シャルブ= b.charAt（I） - 48 =結果+; 
                結果）{CHARA;
                もし（結果<0 ）{ 
                    結果 + = 10 。
                    ISOVER - ; 
                } 
                結果 =結果- シャルブ。
                もし（結果<0 ）{ 
                    結果 + = 10 。
                    ISOVER - ; 
                } 
            } 他{ 
                結果 =キャラ+の結果。
                もし（結果<0 
                    結果 + = 10、
                    ISOVER - ; 
                } 
            } 
            builder.append（結果）。
        } 
        戻りexpungeZero（リバース（builder.toString（）））。
    } 

    // 反序
    プライベート 静的文字列の逆（文字列値）{
         場合（値== NULL || value.length（）<= 1 ）{
             戻り値。
        } 
        戻り逆（value.substring（1））+ value.charAt（0 ）。
    } 

    // 取零的前缀
    プライベート 静的文字expungeZero（文字列s）{
        返す（ ""、 "^ 0 *" s.replaceFirstを）
    } 

    プライベート 静的文字列EXPUNGE（文字列S）{
         戻り s.replaceFirst（ "^ - *"、 "" ）; 
    } 

    プライベート 静的 ブールisLeftBig（文字列、列B）{
         場合（a.length（）== てb.length（））{
             戻り a.compareTo（B）> 0 。
        } 
        であれば（a.length（）> てb.length（））{
             戻り 真。
        } 
        を返す 偽。
    } 

}