Les chaînes Java sont converties en expressions arithmétiques pour calculer et sortir les résultats. Cet outil peut calculer directement les expressions arithmétiques sous forme de chaînes, et elle est très simple à utiliser.
Cet outil contient une calculatrice de deux classes et Arithhelper
Le code de la calculatrice est le suivant:
Importer java.util.collections; Importer java.util.stack; / ** * Évaluation de l'expression arithmétique * Conversion de méthode de classe de calculatrice d'appel directement () * Le processus de calcul est incorrect, une nan sera retournée * / Public Class Calculator {pile privée <string> postfixstack = new Strile <);); Stack <acactor> opstack = new Stack <Comacacter> (); // Operator Stack Private int [] opératorPriority = new int [] {0, 3, 2, 1, -1, 1, 0, 2}; // priority de l'opérateur à l'aide de l'opérateur ASCII Code-40 pour l'indexation du public statique public (TRYPLEMENT (Expression de chaîne) {Double resulte = 0; calculator calle = new Calculator (); Try {Expression = TRANGER); cal.calculate (expression);} catch (exception e) {// e.printStackTrace (); // l'erreur de fonctionnement renvoie nanreturn 0.0 / 0.0;} // retourne la nouvelle chaîne (). Valeurof (résultat); Retour Résultat;} / ** * Modifier le symbole des nombres négatifs dans l'expression * * @param expression * par exemple -2 + -1 * (- 3e-2) - - ~ 2 + ~ 1 * (~ 3e ~ 2) - (~ 1) * @return * / private static String transform (String expression) {char [] arr = expression.tocharay (); for (int i = 0; i <arr.length; i ++) {if (arr [i] == '-') {if (i == 0) {arr [i] = '~'; (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'e' || c == 'e') {arr [i] = '~';}}}} if (arr [0] == '~' || arr [1] == '(' ') {Arr [0] =' '. String (arr);} else {return new String (arr);}} / ** * calculer en fonction de l'expression donnée * * @param Expression * L'expression à calculer par exemple: 5 + 12 * (3 + 5) / 7 * @return * / public double calcul (String Expression) {Strial <string> resultStack = new Stack <string> (); Expression); Collections.rewerse FirstValue, SecondValue, CurrentValue; // La première valeur, SecondValue, CurrentValue; // la première valeur, la deuxième valeur et l'opérateur arithmétique participant au calcul while (! postfixstack.isempty ()) {CurrentValue = PostFixStack Il dans l'opérand pile currentValue = currentValue.replace ("~", "-"); resultStack.push (currentValue);} else {// s'il s'agit d'un opérateur, prenez deux valeurs de l'opérand Stack et participez à l'opération ensemble avec la valeur secondValue = ResultStack.pop (); FirstValue = ResultStack.pop (); // changer le numéro négatif pour a négatif = résultat. FirstValue.replace ("~", "-"); SecondValue = SecondValue.replace ("~", "-"); String TempResult = Calcule (FirstValue, SecondValue, CurrentValue.Charat (0)); ResultStack.push (tempresult);}} convertit l'expression en une pile de suffixes * * @param expression * / private void prépare (Expression de chaîne) {opstack.push (','); // L'opérateur met la virgule dans l'élément inférieur de la pile, et ce symbole a la position de caractère la plus basse [] arr = expression.tocharArray (); int couverte de la dernière position de la caractéristique en cours d'opérateur actuel est intra = 0; // la longueur de la dernière caractéristique de l'opérateur actuel est intron Cet opérateur arithmétique est pratique ou numérique CurrentOP Current, peekop; // l'opérateur actuel et l'opérateur supérieur pour (int i = 0; i <arr.length; i ++) {currentop = arr [i]; if (isoperator (currentop)) {// si le caractère actuel est un opérateur if (count> 0) {postfixStack.push (new String (arrtor, actual, {post) Le nombre entre deux opérateurs} peekop = opstack.Peek (); if (currentOp == ')') {// Lorsque vous rencontrez un Unbranch, supprimez l'élément dans la pile de l'opérateur à la pile de suffixe jusqu'à ce que le support d'ouverture soit rencontré (Opstack.Peek ()! = '(') {postfixstack.push (string.valueof (opstack.pop ()));} opstack.pop ();} else {while (currentop! = '(' && peekop! = ',' && compare (actuel, opstack.pop ()); pekop = pekop = OPSTACK.PEEK ();} OPSTACK.PUSH (CurrentOp);} count = 0; currentIndex = i + 1;} else {count ++;}} if (count> 1 || (count == 1 &&! isOperator (arr [currentIndex]))) {// si le dernier caractère n'est pas une nette ou un autre opérateur, ARRY, Add It to the Suffix Stack PostFixS CurrentIndex, Count));} while (opstack.peek ()! = ',') {postfixstack.push (string.valueof (opstack.pop ())); // Ajoutez les éléments restants dans la pile de l'opérateur à la pile de suffixes}} / ** * C == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ') Cur, retour true, la priorité par défaut de PEEK est un résultat booléen inférieur = false; FirstValue, String SecondValue, Char CurrentOP) {String result = ""; Switch (currentOp) {case '+': result = string.valueof (arithhelper.add (firstValue, SecondValue)); casse; case '-': result = string.valueof (arithhelper.sub (FirstValue, SecondValue); String.valueof (arithHelper.mul (FirstValue, SecondValue)); Break; Case '/': result = string.valueof (arithHelper.div (FirstValue, SecondValue)); Break;} Retour Result;}}Le code Arithhelper est le suivant:
classe publique arithhelper {// la division de la division par défaut précision de fonctionnement privé statique final int def_div_scale = 16; // Cette classe ne peut pas être instanciée privée arithhelper () {} / ** * fournit des opérations d'addition précises. * * @param v1 ajouté * @param v2 add * @return la somme des deux paramètres * / public static double add (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (double.tostring (v1)); java.math.bigdecimal b2 = new java.math.bigdecimal (double.toString (v2)); retour b1.add (b2) .doubleValue ();} public static double add (String v1, string v2) {java.math.bigdecimal b1 = new Java.bigdecimal = newswe java.math.bigdecimal (v2); retour b1.add (b2) .doubleValue ();} / ** * fournit des opérations de soustraction précises. * * @param v1 soustrait * @param v2 soustrait * @return Différence entre deux paramètres * / public static double sub (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (double.tostring (v1)); java.math.bigdecimal b2 = new java.math.bigdecimal (double.toString (v2)); retour b1.substract (b2) .doubleValue ();} public static double sub (String v1, string v2) {java.math.bigdecimal b1 = new Java.mathe.Bigalal (v1); java.math.bigdecimal (v2); return b1.substract (b2) .doubleValue ();} / ** * fournit des opérations de multiplication précises. * * @param v1 * Multiplicateur * @param v2 * Multiplicateur * @return Produit de deux paramètres * / public static double Mul (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (double.toString (v1)); java.math.bigdecimal (double.tostring (v2)); retour b1.multiply (b2) .doubleValue ();} public static double mul (String v1, string v2) {java.math.bigdecimal b1 = new Java.bigdecimal (v1); java. new java.math.bigdecimal (v2); retour b1.multiply (b2) .doubleValue ();} / ** * fournit une opération de division précise (relativement) précise. Lorsqu'il n'y a pas de division, il est exact à 10 chiffres après le point décimal et les numéros suivants sont arrondis. * * @param v1 * Divider * @param v2 * Divider * @return Quoation de deux paramètres * / public static double div (double v1, double v2) {return div (v1, v2, def_div_scale);} public static Double div (String v1, string v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (v1); java.math.bigdecimal b2 = new java.math.bigdecimal (v2); retour b1.divide (b2, def_div_scale, java.math.bigdecimal.round_half_up) .DoubleValue ();} Opération de division. Lorsqu'il n'y a pas de fin pour terminer la séparation, la précision est spécifiée par le paramètre de l'échelle et les nombres suivants sont arrondis. * * @param v1 Divider * @param v2 Divider * @param échelle signifie qu'il doit être précis à plusieurs chiffres après le point décimal. * @return quotient de deux paramètres * / public static double div (double v1, double v2, int balance) {if (échelle <0) {lance un nouveau illégalargumentException ("l'échelle doit être un entier positif ou zéro");} java.math.bigdecimal b1 = new java.math.bigdecimal (double.tostring (v1)); java.math.bigdecimal b2 = new java.math.bigdecimal (double.tostring (v2)); retour b1.divide (b2, échelle, java.math.bigdecimal.round_half_up) .doubleValue ();} / ** * fournit un arrondi décimal précis. * * @param v Comptes qui doivent être arrondis * @param échelle combien de chiffres sont conservés après le point décimal * @return le résultat après l'arrondi * / Double statique public (double v, échelle int) {if (échelle <0) {lancez un nouveau java. java.math.bigdecimal (double.toString (v)); java.math.bigdecimal one = new java.math.bigdecimal ("1"); retour b.divide (one, échelle, java.math.bigdecimal.round_half_up) .DoubleValue ();} Public Static Double V, INTCHE {if (échelle <0) {lancer un nouveau IllégalArgumentException ("l'échelle doit être un entier ou un zéro positif");} java.math.bigdecimal b = new java.math.bigdecimal (v); java.math.bigdecimal One = new Java.Math.bigDecimal ("1"); java.math.bigdecimal.round_half_up) .doubleValue ();}}Lorsque vous l'utilisez, appelez la méthode de conversion () de la classe de calculatrice et passez dans le paramètre d'expression arithmétique pour renvoyer une valeur de type double.
Exemple d'utilisation:
classe publique MathTest {public static void main (String [] args) {String expression = "(0 * 1--3) -5 / -4- (3 * (- 2.13))"; double résultat = calculator.conversion (expression); System.out.println (expression + "=" + result); System.out.println ();}}Sortie de la console:
(0 * 1--3) -5 / -4- (3 * (- 2.13)) = 10,64
Capture d'écran de test:
Résumer
Ce qui précède est toute l'explication détaillée du code d'expression mathématique de calcul Java, j'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!