Récemment, j'ai vérifié Internet récemment, mais je n'ai pas trouvé le code pour les quatre opérations écrites par Java, donc je la baisse.
1. Explication
Le code n'atteint que quatre opérations simples, supporte +, -, *, /, (, (,) ne peut que calculer la valeur d'expression correcte, et il n'y a pas de vérification de l'expression illégale.
2. Méthode d'implémentation
Étape 1: Convertissez la chaîne d'entrée en liste, qui est principalement utilisée pour convertir la chaîne en atomes: valeur / opérateur / support
Public list trans Calcul actuel Faculté * / String curlet = null; / * Enregistrez la position du premier opérateur dans le caractère TMP * / int loc = 0; / * Strings de symbole * / int len = tmp.length (); i = 0; )) {strist.add (str.substring (0, loc) .trim ());} strList.add (str.substring (loc, loc + 1)); if (0 <str.length ()) {strList.add (str.trim ());} return strList;}Étape 2: Convertir l'expression de collaboration du milieu d'origine en expression du suffixe.
Public String [] MidToend (List Midlist) {Stack EMBL = new Stack (); = (String) it.next (); = embl.size () || "" (".equal * / if (")". result.push (omb.pop ()));} embl.pop ();} else {int p1 = Integer.Parseint ((string) Sign.get (curstr)); Sign.get (embl.Peek ())); Else {while (p1 <= p2 || embl.size ()> 0) {result.push (embl.pop ()); ((String) Sign.get (embl.Peek ()));} EMBL.PUSH (CRST .push (embl.pop ());} int len = result .size (); String [] ret = new String [Len]; [Len -i -1] = (String) result.pop ();} return ret;}Étape 3: Le résultat final de l'analyse de l'expression du suffixe, renvoyant le calcul du calcul
/ ** * analyse l'expression du suffixe et renvoie le résultat de l'opération correspondante * @param String [] EndStr l'expression du suffixe converti * @return objet renvoie le résultat de l'opération Si l'expression est incorrecte, imprimez "Erreur d'entrée" directement * / objet public calculer (String [] ENDST) {int len = endstr.length; Endst r [i]) {try {p2 = double.parsed allocation (string) callc.pop ()); ); Return "Input Error";} Catch (Exception ex) {ex.printstacktrace (). ; Return "input error";} } Else {Calc.push (Endstr [i]);}}} if (1 == Calc.size ()) {return calcc.pop ();} else {return "Erreur d'entrée";} / *** Implémentation de la fonction d'opération sous-jacente * @param double p1 numéro 1 * @param double p1 numéro 2 * @param Opérateur de chaîne + - / * * / public double simpcalc (double p1, double p2, opérateur de chaîne) {swit ch (open.charat (0)) {case '+': return p1 + p2; -p2; case '*': Retour p1 * P2;Étape 4: La priorité de l'opérateur est placée dans le cache pour l'extraction
Signe de hashmap statique privé = new hashmap (); )); "0");}
Code complet
Importation java.util.arraylist; et opérations de division et de support * Par exemple: 3 + 12 + 25 * (20-20 / 4) +10 * @author guobo 2009-3-16 * @version 1.0 * / public class CalculeExp {private static hashmap signe = new H Ashmap (); / * Mettez la priorité de l'opérateur dans le traitement du cache * / public Call () {Sign.put (")," 3 "); Sign.put (" * "," 2 "); signe. put (/ "," 2 "); )); ) +10 * Le résultat de la conversion est: * l'élément de liste est ret = {3, +, +, 25, *, (, 20, 20, 20, //, 4, 4,), +, 10} * / public list transstr (string str) {list strList = new ArrayList (); / * Obtenez la chaîne de symbole des données proposées * / string tmp = str.replaceAll ("// d *", ""); / * enregistrer L'opérateur actuel * / chaîne curlet = null; / * enregistre la position du premier opérateur dans la chaîne TMP * / int loc = 0; / * la longueur de chaîne de symbole * / int len = tmp.length (); int i = 0; i <len; i ++) {curlet = tmp.substring (i, i + 1); () "". , Loc, loc, loc, loc, loc, loc, loc + 1); );} Return strlist;} / *** convertira les expressions des expressions infixes en suffixes expressions (polonais) * @param liste liste des expressions analysées * @return String [] Expression converti Array * / public String [] Midtoend (liste midlist) {pile embl = new Stack (); / if (Sign.ContainsKey (curstr)) {/ * Si la pile de symboles est vide ou si le symbole est (* / if (0 == embl.size () || "(". ". Equals (curstr)) { EMBL.PUSH (curstr);} else {/ * Si le symbole est), la pile de symboles doit être hors de la pile jusqu'à un (jusqu'à présent * / if (")". Equals (curstr)) {while (!! "(" (".equals ((string) embl.Peek ())) {if (0> = embl.size ()) {return null;} result.push (embl.pop ()));} EMBL. pop ();} else {int p1 = Integer.Parseint ((String) Sign.get (curstr)); La priorité actuelle du caractère actuel de la priorité que le symbole supérieur de la pile * / if (p1> p2) {embl.push (curstr);} else {while (p1 <= p2 || embl.size ()> 0) {Result.push (embl .pop ()); .push (curstr);}}} else {result.push (curstron (); Ret;} / *** Expression du suffixe d'analyse, renvoie le résultat de l'opération correspondante * @param String [] ENDSTR L'expression du suffixe converti * @return objet renvoie le résultat de l'opération Si l'expression est incorrecte, imprimez "Erreur d'entrée" * / objet public Calculer (String [] ENDST) {int len = Endstr.Length; .ContainsKey (Endstr [i]))) {) {try {p2 = double.PARSED ALLAGE (String) callc.pop ()); i]));} catch (NumberFormatexception ex) {ex.printStackTrace (); [i]);}} if (1 == calcc.size ()) {return calcc.pop ();} else {return "Erreur d'entrée";} / *** réalisez la fonction de calcul sous-jacente * @param double p1 Numéro 1 * @param Double P1 Numéro 2 * @param String Operator + - / * * / public double simpcalc (double p1, double p2, opérateur de chaîne) {switch (oper.char at (0)) {{case '+' : Retour P1 + P2; / Placer Static void main (String [] args) {CalculpExp ce = new CalculatExp (); ) ce.Calculate (ce.midtoend (ce.transstr (tmp)); Double Value = 0; ;Ce qui suit est un supplément des autres internautes
L'idée du code est de calculer chaque unité de calcul minimum par jugement régulier. Ce qui suit est le code:
import java.math.bigdecimal; import java.util.regex.matcher; import java.util.regex.pattern; / ** * Classe d'outils de calculatrice * @author shuqi * @date 2015-7-23 * @ version depuis 1.0 * / CalculatorUtil de classe publique {public static bigdecimal arithmetic (String exp) {if (! Exp.matic ("// d +") {String result = paSeExp (exp) .re placeAll ("[// [//]]" " "," "); Return new Bigdecimal (result);} else {return new BigDecimal (exp);} / *** Unité de comptage minimum *** / private String =" ^^ ((// d + ((// d + (// d + //. // d +)) izing (//.//d+)?)| (///////d+(/./d+)?// "; / ** * Opération sans supports * / chaîne statique privée notarentheses =" ^^ // (//)] + $ "; / *** MOLTIFICATION DE MULTIPLICATION OU DE DIVISION * / STRACHE PRIVÉE PRIETATOREXP =" (// d + (//.// d +)? / d +)?) | (// [// d + (///// d +)? ///])) "/ *** Addition et soumission ) || -1 (///// d + // d + off .//d+))|-1 (//// - / d + (// // d +)? ////////// /////////////// dmi))) ")") ")"; ** Analyser et calculer les quatre expressions d'opérations, par exemple: 2 + ((3 + 4) * 2-22) / 2 * 3 * @param Expression * @return * / private static String paSeExp (String Expression) {// La méthode entre et remplace d'abord l'espace, et supprime le nombre () des deux côtés de l'opération expression = expression.replaceAll ("// s +", "") .replaceAll ("^ // (([^ // // (/)] +) //) dollars 0? Résultat: "[" + Résultat + "]";} // Calculez quatre opérations sans supports if (expression.matches (noparenthes es)) {Pattern Patt = Pattern. )); .matcher (expression); Calculez quatre opérations avec le modèle de support = motif. , parseExp (tempMinexp));} return parseExp (expression);} / ** * = Exp.ReplaceAll ("[// [/]" "," "); Numéro de chaîne [] = exp.replaceFirst (" (// d) [[// d) [["// + // - / / * ///] "," 1, "). Split (", "); Opérateur = exp.replaceFirst ("^^. * // d ([////////////// bus", "$ 1"), + ". Equals (opérateur)) {résultat = Number1.Add (Number2);} else if ("-". Equals (Operator)) {Result = Number1.Subtract (Number2); (Number2);} else if ("/". Equals (Operator)) {// Le deuxième paramètre est la précision, et le troisième est le résultat de mode à cinq couleurs = Number1 .divide (Number2,5, BigDecimal. Round_Ceiling);} Retour Résultat! = Null? Result.ToString (): null;Le code était à l'origine un blog, mais le code n'avait pas de commentaires et il y avait un bug.在这里做个笔记，方便以后用
另为表示对原作者的敬意，附上原始代码
/ ** * Four Calcul d'expression de l'opération * @author Penli * * / public class arithmetic {public static void main (String args []) {System.out.println (arithmetic ("2.2+ ((3 + 4) * 2 - 22) /2*3.2 "));} public static double arithmetic (String exp) {String result = paSeExp (exp) .replaceAll (" [// [//]] "," "); return double.parsed ouble (Résultat);} / ** * Calcul analytique de quatre expressions d'opération, exemple: 2 + ((3 + 4) * 2-22) / 2 * 3 * @param expression * @return * / public static String ParseExp (String Expression) {// String numberReg = "^ ((?! 0) // d + (//.// d + (? <! 0))?) | (0 //.// d + (? <! 0) ) $ "; expression = expression.replaceALL (" // s + "," ") .replaceAll (" ^ // ((. +) //) $ "," $ 1 "); String CheckExp =" // D " ; String minexp = "^ (// d + (//.// d +)?) | (// [// - // d + (//.// d +)? //])) [// + //--//*// $ "; // Le calcul d'expression minimum if (expression.matches (mineXp)) {string res) ult +"] ";} // calculer quatre opérations sans support string noparentheses =" ^ [^ // (//)] + $ "; Chaîne prioroperatorexp =" ((// d + (//.// d +)?) | (/ / [// - // d + (//.// d +)? //]) [// * ///] (// d + (//.// d +)?) | (//// d + (///./d+)?//////////// /]) "; chaîne opératorexp =" ((// d + (//.// d +)?) | (// [// [// - // d + (//.// d +)? //] )) [// + // -] (// d + (//.// d +)?) | (// - // / d + (//// d +)? ///]) ")"; if (expression.matches (not)) {motif patt = motive. );} Else {ompile (opératorexp); . ; Param Exp * @return * / public static String Calcule (String exp) {exp = exp.replaceAll ("[// //]]", ""); : :::::::::::::::::::::::::::::::::::- : :::::::::::::::::::::::::::::::::::- ::::::::::::::::::::::::::::: :: / D) [// + // - // * ///] "," $ 1, " )). ////////// bin $ "," 1 $ "); if (" + ". equals (opérateur)) {result = number1.add (nombre2);} else if (" - ". equals ( Opération)) {result = nombre1.substract (nombre2);} else if "*". = Number1.Divide (Number2); Ult!Enfin, je partagerai avec vous la méthode de mise en œuvre d'un internaute.
Importer Java.util.stack; IS: Utilisation de l'opérateur actuellement obtenu avec les ventilateurs supérieurs de la pile Pristack: s'il est plus élevé, il sera calculé en premier et le mettra en haut de la pile; of operations; * If it is less, the same is true. Take out the top element operation of the stack and put the result into the operating number stack. Each priority '('> ' *' = '/'> '+' = '-'> ')' * * */public class operate {Private Stack <cHaracter> Pristack = New Stack <); // The operating zoning stack Private Stack <Integer> Numstack = New Stack <Integer> (); // Operation number stack/*** Pass in the string that needs to be parsed, and return the calculation results (here is due to time problems, omitting legitimacy verification verification )* @Param Str needs to perform technical expression* @Return Calculation results*/ public into (String Str) {// 1. Determine whether there are illegal characters in String String Temp; // // 2. The loop starts Pour analyser la chaîne. StringBuffer (). APPEND (STR); // Utilisé pour enregistrer et améliorer l'efficacité (String.Length ()! = 0) {temp = String.SubString (0, 1); / Juge temp. tempnum if (! "" ". equals (tempnum.toString ())) {// Lorsque le premier symbole de l'expression est le support int num = Integer.parseint (tempnum.tostring ()); delete (0, tempnum. Length ());} // Utilisez l'opérateur actuellement obtenu pour être prioritaire avec le symbole de calcul d'empilement: s'il est plus élevé, il sera calculé en premier, mis en haut de la pile; Les éléments supérieurs de la pile sont hors de la pile et suppriment le nombre de fonctions d'opérations; // Déterminez la priorité du symbole de calcul actuel et de l'élément supérieur de la pile, éliminez les éléments et calculez (car la priorité peut être inférieure à l'élément supérieur de la pile, il est également inférieur au deuxième élément, etc. ., vous devez utiliser un jugement cyclable). .pop (); = B + A; Résultat); Bream; Le résultat de fonctionnement dans le numéro de fonctionnement de numstack. Caractère (temp.Carat (0))); Dans le support pour calculer et supprimer les parenthèses propack.pop (); pristack.pop ();}}} else // lorsqu'il s'agit d'un symbole non opérant (numérique) tempnum = tempnum. Après avoir reçu le nombre de chiffres lus sur le nombre de lectures (lorsqu'il n'est pas un seul chiffre)} Return numstack.pop (); Boolean privé ISNUM (String Temp) {return temp.matches ("[0-9]");} / ** * Comparez les symboles de fonctionnement actuels et les symboles de fonctionnement de l'élément supérieur de la pile. de la pile, renvoie vrai, sinon il est nécessaire de renvoyer false * * * @param str. ()) {// Lorsqu'il est vide, c'est évidemment la priorité la plus basse. , ')' ne peut pas être le haut de la pile. if (last == '(') {return true;} switch (str) {case '#': return false; // le caractère final "; case ')': // ')') 'la priorité la plus basse, return false; case '*': {// '* /' == '-') return true; ') Return true;' pour le minimum, retourne toujours à False Case '+': return false; ew operate ();