Las cadenas Java se convierten en expresiones aritméticas para calcular y generar los resultados. Esta herramienta puede calcular directamente las expresiones aritméticas en forma de cadenas, y es muy simple de usar.
Esta herramienta contiene dos clases de calculadora y arithhelper
El código de la calculadora es el siguiente:
import java.util.collections; import java.util.stack;/*** Evaluación de expresión aritmética* Llame directamente al método de clase de calculadora ()* Pasar en una expresión aritmética devolverá un valor de valor de flotación* si el proceso de cálculo es incorrecto, un NAN será returado*/calculador de clase pública {stack <string> postfixstack = new stack = new stack = new stack (striD/Strusd//////Sfutor Sfutd/Sfutding; pila privada <caracter> opstack = new Stack <aptact> (); // Operator Stack private int [] operatorRity = new int [] {0, 3, 2, 1, -1, 1, 0, 2}; // prioridad del operador usando operador ASCII Código -40 para indexar publicidad pública Conversión estatica (Expresión de cadena) {Double Result = 0; Calculator Cal Cal = New Calculator (); cal.calculate(expression);}catch (Exception e) {// e.printStackTrace();// Operation error returns NaNreturn 0.0 / 0.0;}// return new String().valueOf(result);return result;}/** * Change the symbol of negative numbers in the expression* * @param expression * For example -2+-1*(-3E-2)-(-1) is converted to ~ 2+~ 1 *(~ 3e ~ 2)-(~ 1) *@return */private static string transform (string expression) {char [] arr = expresion.toCarArRay (); for (int i = 0; i <arr.length; i ++) {if (arr [i] == '-'-') {i == 0) {arr [i] =' ~ ';} más (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'e' || c == 'e') {arr [i] = '' ~;}}}}} if (arr [0] == '' '' '' '' ARR [1] == '(') {0] = ''; String (arr);} else {return new String (arr);}}/** * calcule de acuerdo con la expresión dada * * @param expresión * La expresión se calculará por ejemplo: 5+12 * (3+5)/7 * @return */public doble calculación (expresión) {stack <string> resultStack = new stack <String> (); preparar (expresión); colección.reverse (vida (string expresión) STACK String FirstValue, SecondValue, CurrentValue; // El primer valor, SecondValue, CurrentValue; // El primer valor, segundo valor y operador aritmético que participa en el cálculo mientras (! PostfixStack.isEmpty ()) {currentValue = postfixstack.pop (); if (! isOperator (currentValue.charat (0))))) Operador, guárdelo en la pila de operando actualValue = currentValue.replace ("~", "-"); resultStack.push (currentValue);} else {// Si es un operador, tome dos valores desde la pila de operandas y participe en la operación juntas con el valor SecondValue = resultStack.pop (); FirstValue a = result signo negativo FirstValue = FirstValue.replace ("~", "-"); SecondValue = SecondValue.replace ("~", "-"); String Tempresult = Calculate (FirstValue, SecondValue, CurrentValue.Charat (0)); ResultStack.push (Tempresult);}} regreso double.ValueOf (resultStack.pop ());}/** * La etapa de preparación de datos convierte la expresión en una pila de sufijo * * @param expresión */private void prepare (string expression) {opstack.push (','); // El operador pone el coma en el elemento inferior de la pila, y este mando tiene la prioridad más baja [] expresión. 0; // La posición de caracteres actual es int count = 0; // La longitud de los caracteres desde el último operador aritmético a este operador aritmético es conveniente o numérico Char CurrentOp, peekop; // El operador actual y el operador de pila superior para (int i = 0; i <arr.length; i ++) {currentOp = arr [i]; if (isoperator (cotentOp))) (Count> 0) {Postfixstack.push (new String (arr, currentIndex, count)); // Tome el número entre dos operadores} Peekop = opstack.peek (); if (currentOp == ')') {// Cuando se encuentre un nobranch, elimine el elemento en la pila de operadores a la pila sufix {postfixstack.push (String.ValueOf (opstack.pop ())));} opstack.pop ();} else {while (sententOp! = '(' && pheekop! = ',' && compare (currentop, pEekop)) {postfixstack.push (string.pop (opstack.pop (); opstack.peek ();} opstack.push (currentOp);} count = 0; currentIndex = i+1;} else {count ++;}} if (count> 1 || (count == 1 &&! iSoperator (arr [actualindex]))) {// si el último carácter no es un bracket u otro operador, add it the sufix stack stattfix)))))))) currentIndex, count));} while (opstack.peek ()! = ',') {postfixstack.push (string.ValueOf (opstack.pop ())); // Agregue los elementos restantes en la pila de operadores a la pila sufix}}/** * determine si es un símbolo aritmético * * @@param c * @return */privado) {return c == '+' || que CUR, return true, la prioridad de PEEK predeterminada es el resultado booleano más bajo = falso; FirstValue, String SecondValue, Char CurrentOp) {String Result = ""; Switch (CurrentOp) {case '+': result = string String.ValueOf (arithHelper.add (firstValue, SecondValue)); break; case '-': result = String.ValueOf (arithhelper.sub (FirstValue)); break; break; case '*'*'*'*'*'*': d. String.ValueOf (arithhelper.mul (firstValue, SecondValue)); break; case '/': result = string.ValueOf (arithhelper.div (firstValue, SecondValue)); ruptura;} retorno result;}}El código Arithhelper es el siguiente:
clase pública arithhelper {// División predeterminada Precisión de operación privada Estatic Final int def_div_scale = 16; // Esta clase no se puede instanciar private arithhelper () {}/*** proporciona operaciones de adición precisas. * * @param v1 agregado * @param v2 add * @return la suma de los dos parámetros */public static double add (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigDecimal (double.ToString (v1)); java.math.bigdecimal b2 = new = newe java.math.bigDecimal (double.ToString (v2)); return b1.add (b2) .DoubleValue ();} public static static double add (string v1, string v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (v1); java.math.bigdecimal b22 = neo java.math.bigDecimal (v2); return b1.add (b2) .DoubleValue ();}/*** Proporciona operaciones de sustracción precisas. ** @param v1 restado* @param v2 reste* @return diferencia entre dos parámetros*/public static double sub (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (double.ToString (v1)); java.math.bigdecimal b2 = newe java.math.bigDecimal (double.ToString (v2)); return b1.subtract (b2) .DoubleValue ();} public static static double sub (String v1, string v2) {java.math.bigdecimal b1 = new java.math.bigDecimal (v1); java.math.math.b2 = neo java.math.bigDecimal (v2); return b1.subtract (b2) .DoubleValue ();}/*** Proporciona operaciones de multiplicación precisas. * * @param v1 * multiplicador * @param v2 * multiplicador * @return producto de dos parámetros */public static double mul (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (doble.ToString (v1)); java.math.bigdecimal b2 java.math.bigDecimal (double.ToString (v2)); return b1.multiply (b2) .DoubleValue ();} public static static double mul (string v1, string v2) {java.math.bigdecimal b1 = new java.math.bigDecimal (v1); java.bigaMat.mathmat. java.math.bigDecimal (v2); return b1.multyly (b2) .DoubleValue ();}/*** Proporciona (relativamente) operación de división precisa. Cuando no hay división, es exacto a 10 dígitos después del punto decimal, y los números posteriores se redondean. * * @param v1 * divisor * @param v2 * divisor * @return cita de dos parámetros */public static double div (doble v1, doble v2) {return div (v1, v2, def_div_scale);} public static static div (string v1, string v2) {java.math.bigdecimal b1 = newe java.math.bigDecimal (v1); java.math.bigDecimal b2 = new java.math.bigDecimal (v2); return b1.divide (b2, def_div_scale, java.math.bigDecimal.round_half_up) .Doullevalue ();} operación. Cuando no hay fin para completar la separación, la precisión se especifica por el parámetro de escala y los números posteriores se redondean. ** @param v1 divisor* @param v2 divisor* @param escala significa que debe ser preciso para varios dígitos después del punto decimal. * @return cociente de dos parámetros*/public static doube div (doble v1, doble v2, int escala) {if (escala <0) {tire la nueva ilegalargumentException ("La escala debe ser un entero o cero positivo");} java.math.bigDecimal b1 = new = new java.math.bigDecimal (double.ToString (v1)); java.math.bigdecimal b2 = new java.math.bigDecimal (double.ToString (v2)); retorno b1.divide (b2, escala, escala, java.math.bigdecimal.round_half_up) .DoubleValue ();}/*** Proporciona un redondeo decimal preciso. ** @param V cuenta que debe redondearse* @param escala cuántos dígitos se conservan después del punto decimal* @return el resultado después de redondear*/public static double ronda (doble v, int escala) {if (escala <0) {tirar nueva ilegumentException ("La escala debe ser un intento o cero positivo");} java.math.bigDecimal (double.ToString (v)); java.math.bigDecimal one = new java.math.bigDecimal ("1"); return b.divide (one, escala, java.math.bigDecimal.half_up) .Divalue ();} {if (scale <0) {throw New IlegalArgumentException ("La escala debe ser un entero o cero positivo");} java.math.bigdecimal b = new java.math.bigDecimal (v); java.math.bigdecimal one = new java.math.bigdecimal ("1"); regreso, una, una escala, una, una escala, una, una escala, una, una escala, una, una, una escala, una, una, una escala, una, una, una escala, una, una, una escala, una, una, una, una escala, una, una, una, una escala, una, una, una, una, una escala. java.math.bigdecimal.round_half_up) .DoubleValue ();}}Al usarlo, llame al método de conversión () de la clase de calculadora y pase en el parámetro de expresión aritmética para devolver un valor de tipo doble.
Ejemplo de uso:
public class MathTest {public static void main (String [] args) {String Expression = "(0*1-3) -5/-4- (3*(-2.13))"; doble resultado = calculator.conversion (expresión); system.out.println (expresión + "=" + resultado); system.println ();}}}}}}}}}}}}}}}}}}}}}}}}}Salida de la consola:
(0*1--3) -5/-4- (3*(-2.13)) = 10.64
Captura de pantalla de prueba:
Resumir
Lo anterior es toda la explicación detallada del código de expresión matemática computacional Java, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!