スタックの実装RPN電卓（接尾辞）

輸入はjava.util.ArrayList;
輸入はjava.util.List;
輸入java.util.Stackを;

パブリック クラスPolandNotation {

    パブリック 静的 ボイドメイン（文字列[]引数）{
         // 中置サフィックス転送機能
         // 1.1 +（（2 + 3）* 4） - 5 => 1 2 + 3 + 4 * 5 -
         // リストSTR転送動作を容易にする2
         // 後置表現をに変換する変換リスト3 
        列=式」1 +（（2 + 3）* 4）-5" 。;
        一覧 <文字列> infixExpressionList = toInfixExpressionList（式）;
//         するSystem.out.println（infixExpressionList）。
        一覧<文字列> suffixExpressionList = parseSuffixExpressionList（infixExpressionList）。
        System.out.println（suffixExpressionList）。
        System.out.println（計算（suffixExpressionList））。
        // 逆ポーランド記法を定義
         // （30 + 4）= 5-6 *> 5 * 30 + 4 6 -
         @ 4 * 60 + 8 + 5-8 / 2 => 45 * + 8--6 2. 8 / +
         // 985から728×35÷26 => 985 26である* 35分の728である- 
        -文字列suffixExpression = "985 26 * 35分の728である" ;
         // のArrayListにまずsuffixExpression
         // 2 ArrayListのスタックで完了される計算方法に渡さ
 //         リストの<string> rpnList = getListString（suffixExpression）;
 //         するSystem.out.println（ "rpnList =" + rpnList）;
 //         計算RES =（rpnList）をint型;
 //         System.out.println（RES）; 
    }

    // 中置表現ターンpostfixの
    パブリック 静的の一覧<文字列> toInfixExpressionList（文字列S）{
        一覧 <文字列> LS = 新しい新しいのArrayList <文字列> （）;
         int型私= 0; // 文字列横断するため 
        の文字列STRを; // マルチビットスプライシング
        のchar C; // 文字がCに配置された横断を
        行います{
             IF（（C = s.charAt（I））<48 ||（C = s.charAt（I））> 57です）{
                ls.add（ "" + C）。
                I ++ ;
            } 他{
                STR = ""; // 先将STR置成"" 
                ながら（I <s.length（）&&（C = s.charAt（I））> = 48 &&（C = s.charAt（I））<= 57 ）{
                    STR + = C。
                    I ++ ;
                }
                ls.add（STR）。
            }
        } 一方、（I < s.length（））。
        リターンLS;
    }

    公共の 静的リストの<string> parseSuffixExpressionList（リストの<string> LS）{
        スタックの<string> S1 = 新しい新しいスタックの<string>（）; // シンボルスタック 
        リストの<string> S2 = 新しい新規のArrayList <ストリング>（）; // 結果セット
        のための（文字列アイテム：LS）{
             // もし数
            もし（item.matches（ "\\ + D" ））{
                s2.add（アイテム）
            } そう であれば（item.equals（ "（" ））{
                s1.push（アイテム）
            } 他 IF（item.equals（「）」））{
                 // 順次スタックポップオペレータS1、S2が左括弧は、括弧の対は破棄されている追加され遭遇するまで
                しばらく（！S1.peek（）。等号を（「（ ' ））{
                    s2.add（s1.pop（））。
                }
                ）（s1.pop; // 括弧の除去 
            } 他{
                 // オペレータがオペレータにスタックオペレータの上面よりも小さい場合、スタックポップS1及びS2と、スタックの最上部が、オペレータより大きくなるまで比較を継続するために追加（PEEK（ ）ビューを取り出すことなく）
                、一方（s1.size（）！= 0 && Operation.getValue（s1.peek（））> = Operation.getValue（アイテム））{
                    s2.add（s1.pop（））。
                }
                s1.push（項目）; //は積載動作を継続します
            }
        }
        // S1が加え残りのオペレータが順次S2に吐出さ
        しばらく（s1.sizeを（）！= 0 ）{
            s2.add（s1.pop（））。
        }
        返すS2を。
    }

    公共の 静的リストの<string> getListString（文字列suffixExpression）{
        文字列[]スプリット = suffixExpression.split（」 " ）。
        ArrayListの <文字列>リスト= 新しい ArrayListを<> （）;
        用{（分割文字列ELE）
            list.add（ELE）。
        }
        戻り値のリスト。
    }

    / **
     *左から右に1スキャンは数がスタックにあります
     * 2.オペレータは、2つのデジタル計算結果スタックのポップスタックに遭遇しました
     * 3.次の番号を押します
     二つの数字（番号3と2の結果）のスタックは、スタックポップを算出* 4オペレータ次遭遇
     *圧入次の数
     * 6次のポップ・スタックは、オペレータ二つの数字（番号4及び5の結果）最終的な結果に遭遇します
     *
     * @Param 文字のLSセット
     * @return 
     * / 
    パブリック 静的の int型の計算（一覧<文字列> LS）{
        スタック <文字列>スタック= 新しいスタック<文字列> （）;
        用{（LS文字列の項目）
             であれば（item.matches（ "\\ D +" ））{
                stack.push（アイテム）
            } 他{
                 int型からnum2 = Integer.parseInt（stack.pop（））。
                INT NUM1 = Integer.parseInt（stack.pop（））。
                int型のres = 0 ;
                もし（item.equals（ "+" ））{
                    RES = + num1をnum2の。
                } そう であれば（item.equals（ " - " ））{
                    RES = NUM1 - num2の。
                } そう であれば（item.equals（ "*" ））{
                    RES = * NUM1のNUM2。
                } そう であれば（item.equals（ "/" ））{
                    RES = NUM1 / NUM2。
                } 他{
                     スロー 新しい新規のAのRuntimeException（「オペレータエラー」）。
                }
                stack.push（ "" + RES）。
            }
        }
        リターンInteger.parseInt（stack.pop（））;
    }
}

// 対応オペレータ優先戻り
クラスオペレーション{
     プライベート 静的 INT ADD = 1。;
     プライベート 静的 INT SUB = 1 ;
     プライベート 静的 INT = 2 MUL ;
     プライベート 静的 INT = 2 DIV 。

    パブリック 静的 INT のgetValue（文字列操作）{
         int型の結果= 0 。
        スイッチ（操作）{
             場合、 "+" ：
                結果 = ADD;
                休憩;
            ケース " - " ：
                結果 = SUB;
                休憩;
            ケース "*" ：
                結果 = MUL。
                休憩;
            ケース "/" ：
                結果 = DIV。
                休憩;
            ケース "（" ：
                 休憩;
             デフォルト：
                System.out.println（ "演算子はサポートされていません" ）;
                 BREAK ;
        }
        戻り値の結果;
    }
}