Recientemente, revisé Internet recientemente, pero no encontré el código para las cuatro operaciones escritas por Java, por lo que lo reduce.
1. Explicación
El código solo logra cuatro operaciones simples, admite+,-,*,/, (,) solo puede calcular el valor de expresión correcto, y no hay verificación de la expresión ilegal.
2. Método de implementación
Paso 1: Convierta la cadena de entrada en la lista, que se usa principalmente para convertir la cadena en átomos: valor/operador/soporte
Public List Trans Mucho (String Str) {List strList = new ArrayList ();/* Obtenga las cadenas de símbolos de los datos*/String tmp = str.replaceAll ("// d*", "");/* Grabe el Facultad de cálculo actual*/ String Curlet = Null;/*Registre la posición del primer operador en el carácter tmp*/ int loc = 0;/*cadenas de símbolo*/ 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;}Paso 2: Convierta la expresión original de medio a la expresión de sufijo.
Cadena pública [] Midtoend (List Midlist) {pila embl = nueva pila (); = (String) it.next (); = embl.size () || * / if (")". resultado.push (embl.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 ())); .push (embl.pop ());} int len = resultado .size (); [Len -i -1] = (string) result.pop ();} return ret;}Paso 3: El resultado final del análisis de la expresión del sufijo, devolviendo el cálculo del cálculo
/ *** analiza la expresión de sufijo y devuelve el resultado de la operación correspondiente* @param cadena [] endstr la expresión de sufijo convertida* @return el objeto return el resultado de la operación si la expresión es incorrecta, imprima "error de entrada" directamente*/ objeto público calcule (Cadena [] endstr) {int len = endstr.length; endst r [i]) {try {p2 = double ); Calc.size ()) {return calc.pop ();} else {return "Error de entrada";} /*** Implementación La función de operación subyacente* @param doble p1 número 1* @param double p1 número 2* @param Operador de cadena + -/ * */ public Double SimpleCalc (doble p1, doble p2, operador de cadena) {Swit ch (open.charat (0)) {case ' +': return p1 +p2; -p2;Paso 4: La prioridad del operador se coloca en el caché para la extracción
Signo de hashmap privado = nuevo hashmap (); ); "0");}
Código completo
Import java.util.ArrayList; y operaciones de división y soporte * Por ejemplo: 3+12+25 * (20-20/4) +10 * @author Guobo 2009-3-3-16 * @version 1.0 */clase pública Calculatepexp {signo de hashmap estático privado = nuevo H Ashmap ();/*Ponga la prioridad del operador en el procesamiento de caché*/public Calling () {Sign.put (")," 3 "); Sign.put ("*"," 2 "); signo. PUT ("/", "2"); ); ) +10 * El resultado de la conversión es: * El elemento de lista es ret = {3,+,+, 25, *, (, 20, 20, 20, //, 4, 4,),+, 10} * /public List Transstr (String Str) {List strList = new ArrayList ();/* Obtenga la cadena del símbolo de los datos propuestos*/String tmp = str.replacealll ("// d*", "");/* registrar El operador actual*/String curlet = null;/*Registre la posición del primer operador en la cadena tmp*/int loc = 0;/*Longitud de cadena de símbolo*/int len = tmp.length (); int i = 0; () "". , Loc, loc, loc, loc, loc, loc, loc + 1); );} Return strList;}/*** convertirá expresiones de expresiones infijo a expresiones sufijo (polaco)* @param Lista de la lista de expresiones analizadas* @return string [] Convertida Express String Array*/Public String [] Midtoend (LIST Midlist) {pila embl = nueva pila (); /if (sign.containskey (curstr)) {/* Si la pila de símbolos está vacía o el símbolo es (*/if (0 == embl.size () || "(". ". Equals (curstr)) { Embl.push (curstr);} else {/*Si el símbolo es) la pila de símbolos debe estar fuera de la pila hasta que uno (hasta ahora*/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 prioridad de prioridad del personaje actual del personaje actual que el símbolo superior de la pila*/if (p1> p2) {embl.push (curstr);} else {while (p1 <= p2 || embl.size ()> 0) {Result.push (embl .pop ()); .push (curstración);}}} else {result.push (curstr);} while (); Ret;}/*** Análisis de la expresión de sufijo, devuelve el resultado de la operación correspondiente* @param cadena [] endstr la expresión de sufijo convertida* @return return el resultado de la operación si la expresión es incorrecta, imprima "error de entrada"*/objeto público calcular (cadena [] endstr) {int len = endstr.length; .ContainsKey (endstr [i]))) {) {try {p2 = double i]));} Catch (NumberFormexception ex) {Ex.PrintStackTrace (); [i]);}} if (1 == calc.size ()) {return calc.pop ();} else {return "Error de entrada";}/*** Realice la función de computación subyacente* @param doble p1 Número 1 * @param doble p1 número 2 * @param operador de cadena +-/ * */public doble simplecalc (doble p1, doble p2, string operator) {switch (oper.char at (0)) {{case ' +' : Return p1 + p2; /coloque static void main (string [] args) {calculatexp ce = new CalculatingExP (); ) ce.calcule (ce.midtoend (ce.transstr (tmp))); valor doble = 0; ;El siguiente es un suplemento de otros internautas
La idea del código es calcular cada unidad de cálculo mínimo a través del juicio regular. El siguiente es el código:
import java.math.bigDecimal; import java.util.regex.matcher; import java.util.regex.pattern;/** * Clase de herramienta de calculadora * @author shuqi * @date 2015-7-7-23 * @versión desde 1.0 * /Public Class CalculatorUtil {public static static bigDecimal arithmetic (string exp) {if (! Exp.matic ("// d+") {string dult = parseExp (exp) .re placeAll ("[// [//]]" "" " "," "); Return New BigDecimal (resultado);} else {return new BigDecimal (exp);}/*** Unidad de conteo mínimo ***/private string =" ^^ ((// d+((// d+(// d+//. // d+)) izing (//.//d+)?)(//che//-//d+(//.//d+)?//font>)$ ";/***Operación sin soportes*/String static privado Notarentheses =" ^^ // (//)]+$ ";/*** Multiplicación coincidente o método de división*/String private PrioratorExp =" ((// d+(//.// d+)?) /D+)?) | ) || -1 (///// d+ // d+ apagado .//d+)))|-1 (////-/d+ (// // d+)? /////// ////////////// dmi))) ")") "; ** Analice y calcule las cuatro expresiones de operaciones, por ejemplo: 2+((3+4) * 2-22)/2 * 3 * @param expresión * @return */private static string parseexp (expresión de cadena) {// El método ingresa y reemplaza primero el espacio, y elimina el número () en ambos lados de la operación Expression = Expression.ReplaceAll ("// s +", "") .replacealll ("^// (([^// (/)]+) //) $ "," $ 1 "); // Cálculo de expresión mínima if (expresión.matches (minexp)) {string result = calculate (expresión); return double.parsedubo (result)> = 0? Resultado: "["+resultado+"]"; ); .matcher (expresión); Calcule cuatro operaciones con patrón de paréntesis = patrón.compile (minParentheses); , parseexp (tempMinexp));} return parseexp (expresión); = Exp.replaceAll ("[// [/]" "," "); número de cadena [] = exp.replaceFirst (" (// d) [[// d) [["//+//-/ /*///] "," $ 1, "). Split (", ","); Operador = exp.replaceFirst ("^^.*// d ([/////////////// bus", "$ 1"), +". Equals (operador)) {resultado = número1.Add (número2); (número2); Round_ceiling);El código era originalmente un blog, pero el código no tenía comentarios y hubo un error. Tome una nota aquí para usar fácilmente más tarde
Además, para expresar respeto al autor original, se adjunta el código original
/*** Cálculo de expresión de cuatro operaciones* @author penli**/public class arithmetic {public static void main (string args []) {system.out.println (aritmetic ("2.2+ ((3+4)* 2 - 2 - 22) /2*3.2 "));} Public estática aritmética doble (String exp) {String Result = parseExP (exp) .Replacealll (" [// [//]] ","); return Double OUBLED PARSED (resultado); Expresión) {// String numberreg = "^((? ) $ "; expresion = expresion.replaceAll (" // s+"," ") .replaceAll ("^// ((.+) //) $ "," $ 1 "); String checkexp =" // d " ; String minexp = "^((// d+(//// d+)?) | (// [//-// d+(//// d+)? //])) [//+ //-//*///font>(//d+(//.//d+)?)|(/////-//d+(//.//d+)?///]))) $ "; // El cálculo de expresión mínima if (expresion.matches (minexp)) {string res) ult+"] ";} // Calcule cuatro operaciones sin corchetes. $ "; String prioroperatorExp =" (((// d+(//// d+)?) | (//[//-// d+(//.// d+)? //]) [// *///] (// d+(//// d+)?) | /]) "; string operatorExp =" ((// d+(//// d+)?) | (// [// [// -// d+(///// d+)? //] )) [//+//-] (// d+(///// d+)?) | if (expresion.matches (no) {patrón patt = patrón.compile (priorueperexp); );} Else {omPile (operatorExp); );} // Calcule cuatro paréntesis de cadena de computación MinParentheses = "// ([^// (/)]+//)"; ; Param exp * @return */public static string calcule (string exp) {exp = exp.replaceall ("[// [//]]", ""); :::::::::::::::::: para::: ::::::::::::::::::::::::::::::: :::::::::::::::::: para::: ::::::::::::::::::::::::::::::: :::::::::::::::::::::::::::::or no) [//+//-//*///] "," $ 1, ", ) ///////// bin $ "," $ 1 "); if ("+". Equals (Operator)) {result = Number1.Add (número2);} else if ("-". Equals ( Operador)) {result = number1.subtract (número2);} else if " *". = Number1.divide (número2);Finalmente, compartiré con usted el método de implementación de un internautas.
Importar java.util.stack; IS: Uso del operador obtenido actualmente con los ventiladores Top de la pila Pristack: si es más alto, se calculará primero y lo colocará en la parte superior de la pila; de operaciones; Cada prioridad '('> ' *' = '/'> '+' = '-'> ')' * * */public class operate {private stack <caracter> pristack = new Stack <); pila pila privada <integer> numStack = new Stack <Integer> (); Verificación de verificación)* @param str necesita realizar la expresión técnica* @return resultados de cálculo*/ public en (string str) {// 1. Determine si hay caracteres ilegales en la cadena de cadena temp; Para analizar la cadena. StringBuffer (). Append (str); // Usado para guardar y mejorar la eficiencia mientras (String.Length ()! = 0) {temp = String.substring (0, 1); / Juez Temp. tempnum if (! "" ". Equals (tempNum.ToString ())) {// Cuando el primer símbolo de la expresión es el soporte int longitud ());} // Use el operador obtenido actualmente para ser priorizado con el símbolo de cálculo de apilamiento: si es más alto, se calculará primero, se pondrá en la parte superior de la pila; Los elementos principales de la pila están fuera de la pila y eliminan el número de operación de operaciones; // Determine la prioridad del símbolo de computación actual y el elemento superior de la pila, elimine los elementos y calcule (porque la prioridad puede ser menor que el elemento superior de la pila, también es menor que el segundo elemento, etc. ., necesita usar un ciclo de juicio). .pop ();/ primero char ope = pristack.pop (); = b + a; resultado); el resultado operativo en el número de operación de NUMSTRACE. Personaje (temp.charat (0))); en el soporte para calcular y eliminar los paréntesis propack.pop (); Después de recibir el número de dígitos leídos al número de lecturas (cuando no es un solo dígito)} return numstack.pop () es un número 0-9 * * * @param str * cadena transmitida * @return * / Private Boolean isNum (Temp) {return temp.matches ("[0-9]");} / ** * Compare los símbolos operativos actuales y los símbolos operativos del elemento superior de la pila. de la pila, devuelve verdadero, de lo contrario, es necesario devolver falso * * * @param str. ()) {// Cuando está vacío, es obviamente la prioridad más baja. , ')' no puede ser la parte superior de la pila. if (last == '(') {return true;} switch (str) {case '#': return false; // el carácter final "; case ')': // ')') 'La prioridad más baja, return false; ') Return true; ew operate ();