As cadeias Java são convertidas em expressões aritméticas para calcular e produzir os resultados. Essa ferramenta pode calcular diretamente expressões aritméticas na forma de strings e é muito simples de usar.
Esta ferramenta contém duas classes calculadora e arithelper
O código da calculadora é o seguinte:
importar java.util.Collections; importar java.util.stack;/*** avaliação da expressão aritmética* diretamente chama o método de classe da calculadora Conversão ()* Passagem em uma expressão aritmética retornará um valor de ponto flutuante) se o processo de cálculo estiver incorreto, uma NAN será retornada*/calculadora de classe pública (STRING <ctrack> Stack <Acfaracter> opStack = new Stack <Acfaracter> (); // pilha do operador private Int [] operatorPriority = new int [] {0, 3, 2, 1, -1, 1, 0, 2}; // Prioridade do operador usando o operador ASCII Code -40 para indexação public Double conversão dupla (String (String) {Double (Double Double); Cal.Calculate (Expression);} Catch (Exceção e) {// E.PrintStackTrace (); // Erro de operação Retorna NanReturn 0.0/ 0.0;} // retorna new String (). ValueOf (resultado); resultação de retorno;}/ *** Altere o símbolo de números negativos na expressão* @PARAM* para o exemplo -2 -2 -2 -2+-1-1-1-1-1-1 *** Alterar o símbolo da expressão** @Param* para o exemplo -2 -2 -2 -2+-1-1-1-1-1-1-1-1-1 *** ~ 2+~ 1 *(~ 3e ~ 2)-(~ 1) *@return */String estática privada Transform (expressão de string) {char [] arr = Expression.ToCharArray (); para (int i = 0; i <arn.length; i ++) {if (arr [i] == '-') {if (i == 0) {[ARR]; (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'e' || c == 'e') {arr [i] = '~';}}}}} se (arr [0] == '~ |) = ~ [1]; String (arr);} else {return new String (arr);}}/** * Calcule de acordo com a expressão dada * * @Param Expression * A expressão a ser calculada por exemplo: 5+12 * (3+5)/7 * @return */public calcular (String Expression) {Stack <string> resultado Stack String FirstValue, SecondValue, CurrentValue; // O primeiro valor, SecondValue, CurrentValue; // O primeiro valor, o segundo valor e o operador aritmético participando do cálculo enquanto (! PostfixStack.IsEmpty (CurrentValue.at.at (pós -fixStack.pop); if (! isoperator (curtValue.at.at (0,1) () o operador (não -operador) {Currentvalue = PostFixStack.pop (); if (! isoperator (curtValue.at.at (0,5) (não -operador) {CurrentVacke.at (0,1); Stack CurrentValue = CurrentValue.Replace ("~", "-"); resultStack.push (currentValue);} else {// Se for um operador, pegue dois valores da pilha de operando e participe da operação juntamente com o valor SecondValue = ResultStack.POP () NORMEVELUE ASTIMENTALE = ResultActack.pop (); FirstValue.replace ("~", "-"); SecondValue = SecondValue.Replace ("~", "-"); String tempreSult = Calcule (FirstValue, SecondValue, CurrentValue.Charat (0)); ResultStack.Push (TEMPRULT);}}}/DoubleOf (resultestack.POP.POP (); Stack * * @param Expression */private void preparar (expressão de string) {opstack.push (','); // O operador coloca a vírgula no elemento inferior da pilha, e esse símbolo tem a menor prioridade de char [] Arrest = Expression.ToCharArray (); Int CurrentIndex = 0; da posição atual da corrente é int = 0; é conveniente ou numérico Char CurrentOp, Peekop; // O operador atual e o operador de pilha superior para (int i = 0; i <arr.length; i ++) {currentOp = arr [i]; if (isoperator (currentOp)) {// se o caractere atual é um operador if (count> 0) {postfixStack.push) {// se o caractere atual é um operador if (count> 0) {postfixstack.ph.push (strings) (count) {postfixs) {// string (count) {postfixStack) {// operadores} peekop = opstack.peek (); if (currentOp == ')') {// Ao encontrar um não -branch, remova o elemento na pilha do operador na pilha do sufixo até que o suporte de abertura seja encontrado (opstack.peek ()! = (') {postfixstack.push (string.valueof (opstack.pop ()));} opstack.pop ();} else {while (currentOp! = '(' && peekop! opstack.peek ();} opstack.push (currentOp);} count = 0; currentIndex = i+1;} else {count ++;}} if (count> 1 || (count == 1 &&! isoperator (Arr [currentIndex])) {// se o último caractere não é uma piada ou outra, o operador, slow (ARR [CurrentIndex])) »{//, se o último caractere não é uma statack ou outro currentIndex, count));} while (opstack.peek ()! = ',') {postfixStack.push (string.valueof (opstack.pop ())); // Adicione os elementos restantes na pilha do operador * * @cadasTean @CHETOM @CHETOMATEM * C == '+' | CUR, Retorne True, a prioridade de espidade padrão é menor resultado booleano = false; CHAR CURRENOP) {String result = ""; switch (currentOp) {case '+': resultado = string.valueof (arithhelper.add (FirstValue, SecondValue)); Break; case '-': resultado = string.Valueof (arithHelper.sub (FirstValue, SecondValue); quebra; SecondValue)); Break; case '/': resultado = string.valueof (arithhelper.div (FirstValue, SecondValue)); Break;} Resultado de retorno;}}O código arithelper é o seguinte:
Classe pública Arithhelper {// Divisão padrão Operação Precisão privada estática final Int DEF_Div_Scale = 16; // Esta classe não pode ser instanciada private arithelper () {}/*** fornece operações de adição precisas. * * @param v1 adicionado * @param v2 Adicione * @return a soma dos dois parâmetros */public static duplo add (v1 duplo, duplo v2) {java.math.bigdecimal b1 = new java.math.math.bigdecimal (duplo.toString (v1)); java.math.bigdecimal (duplo.toString (v2)); retorna b1.add (b2) .doubleValue ();} public static duplo add (string v1, string v2) {java.math.bigdecimal b1 = java.math.bigDecimal (V1) (java.math.bigDecimal.math.bigdecimal b1 = java.math.bigDecimal (V1) java.math.bigdecimal (v2); retorno b1.add (b2) .doubleValue ();}/*** fornece operações de subtração precisas. ** @param v1 subtraído* @param v2 subtraia* @return diferença entre dois parâmetros*/public static duplo sub (Double v1, duplo v2) {java.math.bigdecimal b1 = new java.math.math.bigdecimal (duplo.ToString (v1)); java.mathb.math.math.math.math.math.math.math.bigdecimal (duplo. java.math.bigdecimal (duplo.toString (v2)); retorna b1.subtract (b2) .doubleValue ();} public static duplo sub (string v1, string v2) {java.math.bigdecimal b1 = java.math.bigdimal (V1) java.math.bigdecimal (v2); retorno b1.subtract (b2) .doubleValue ();}/*** fornece operações de multiplicação precisas. * * @param v1 * multiplicador * @param v2 * multiplicador * @return Produto de dois parâmetros */public static duplo mul (v1 duplo, v2 duplo) {java.math.bigdecimal b1 = new java.math.bigdecimal (duplo.tostring (v1); java.math.bigdecimal (duplo.toString (v2)); retorna b1.multiply (b2) .doubleValue ();} public static duplo mul (string v1, string v2) {java.math.bigdecimal b1 = java.ath.bigDimal java.math.bigdecimal (v2); retorno b1.multiPly (b2) .doubleValue ();}/*** fornece (relativamente) operação de divisão precisa. Quando não há divisão, ela é precisa de 10 dígitos após o ponto decimal, e os números subsequentes são arredondados. * * @param v1 * divisor * @param v2 * divisor * @return citação de dois parâmetros */public static duplo div (duplo v1, duplo v2) {return div (v1, v2, def_div_scale);} public static duplo div (string v1) {java.math.bigdal java.math.bigdecimal (v1); java.math.bigdecimal b2 = new java.math.bigdecimal (v2); retorno b1.divida (b2, DEF_DIV_SCale, java.math.bigdeCimal.round_half_half_) operação. Quando não há fim para concluir a separação, a precisão é especificada pelo parâmetro de escala e os números subsequentes são arredondados. ** @param v1 divisor* @param v2 divisor* @param escala significa que precisa ser preciso para vários dígitos após o ponto decimal. * @return quociente de dois parâmetros*/public static duplo div (duplo v1, v2 duplo, int) {if (escala <0) {tiro novo ilegalargumentException ("a escala deve ser um número inteiro positivo ou zero");} java.math.bigdecimal b1 = novo "); java.math.bigdecimal (duplo.toString (v1)); java.math.bigdecimal b2 = new java.math.bigdecimal (duplo.toString (v2)); retorno b1.divida (b2, escala, java.math.big e * Fornece arredondamento decimal preciso. ** @param v contagens que precisam ser arredondadas* @param escala Quantos dígitos são retidos após o ponto decimal* @Return o resultado após arredondamento*/public estático Round Double Round (Double V, int) {if (escala <0) {lança new ilegalargumentException ("A escala deve ser um inteiro positivo ou zero"); java.math.bigdecimal (duplo.toString (v)); java.math.bigdecimal one = new java.math.bigdecimal ("1"); retorno b.divida (scale, java.math.bigdecimal.rund_half_alf_). (escala <0) {jogue novo ilegalArgumentException ("A escala deve ser um número inteiro positivo ou zero");} java.math.bigdecimal b = new java.math.bigdecimal (v); java.math.bigdecimal um = novo java.math.bigddent java.math.bigdecimal.round_half_up) .doubleValue ();}}Ao usá -lo, ligue para o método conversion () da classe Calculadora e passe no parâmetro de expressão aritmética para retornar um valor do tipo duplo.
Exemplo de uso:
public class Mathtest {public static void main (string [] args) {string expressão = "(0*1--3) -5/-4- (3*(-2.13))"; resultado duplo = calculator.conversão (expressão); System.out.println (expressão + "=" + resultado); System.out.println;Saída do console:
(0*1--3) -5/-4- (3*(-2.13)) = 10.64
Screenshot de teste:
Resumir
O exposto acima é toda a explicação detalhada do código de expressão matemática computacional Java, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!