Recentemente, verifiquei a Internet recentemente, mas não encontrei o código para as quatro operações escritas por Java, então eu a abaixei.
1. Explicação
O código atinge apenas quatro operações simples, suporta+,-,*,/, (, (,) pode apenas calcular o valor de expressão correto e não há verificação da expressão ilegal.
2. Método de implementação
Etapa 1: Converta a sequência de entrada em List, que é usada principalmente para converter string em átomos: Valor/Operador/Suporte
List public trans muito (string str) {list strlist = new ArrayList ();/* Obtenha as seqüências de símbolo dos dados*/string tmp = str.replaceall ("// d*", "");/* Registre o Faculdade de cálculo atual*/ String CURLET = NULL;*Registre a posição do primeiro operador no caractere tmp*/ int loc = 0;/*Strings 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 ());} retorna strlist;}Etapa 2: Converta a expressão corporada média original na expressão do sufixo.
Public String [] Midtoend (Lista MIDLIST) {pilha EMBL = new Stack (); = (String) it.next (); = EMBL.SIZE () || "(" .Equals (Curstr)) {EMBL.PUSH (Curstr);} else { /*Se o símbolo for) * / if (")". Result.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) {resultado.push (EMBL.POP ()); ((String) Sign.get (EMBL.PEEK ())); .push (embl.pop ());} int len = resultado .size (); [Len -i -1] = (string) resultado.pop ();} retornar ret;}Etapa 3: o resultado final da análise da expressão do sufixo, retornando o cálculo do cálculo
/ *** analisa a expressão do sufixo e retorna o resultado da operação correspondente* @param string [] endstr a expressão do sufixo convertido* @return Objeto retornar o resultado da operação Se a expressão estiver incorreta, imprima "Erro de entrada" diretamente*/ objeto público calcular (String [] ENDST) {int len = endstr.length; endst r [i]) {tente {p2 = Double.parsed Subsídio (String) calc.pop ()); ); Calc.size ()) {return calc.pop ();} else {return "Error de entrada";} /*** Implementação A função de operação subjacente* @param duplo p1 número 1* @param duplo número 2* @param Operador de string + -/ * */ public Double SimpleCalc (Double P1, Double P2, String Operator) {Swit CH (Open.Charat (0)) {case ' +': retornar P1 +P2; -p2;Etapa 4: A prioridade do operador é colocada no cache para extração
Signo estático privado = novo hashmap (); ); "0");}
Código completo
Importar java.util.arraylist; e operações de divisão e suporte * por exemplo: 3+12+25 * (20-20/4) +10 * @Author Guobo 2009-3-16 * @version 1.0 */public class CalcularExp {private Static Hashmap sinal = novo H ashmap ();/*Coloque a prioridade do operador no processamento do cache*/public Calling () {Sign.put (")," 3 "); sinal.put ("*"," 2 "); sinal. Put ("/", "2"); ); ) +10 * O resultado da conversão é: * O elemento de lista é ret = {3,+,+, 25, *, (, 20, 20, 20, //, 4, 4,),+, 10} * /list public transstr (string str) {list strlist = new ArrayList ();/* Obtenha a sequência de símbolos dos dados propostos*/string tmp = str.replaceall ("// d*", "");/* registro O operador atual*/string curlet = null;/*Registre a posição do primeiro operador na sequência tmp*/int loc = 0;*Symbol String Comprimento*/int len = tmp.length (); int i = 0; () "". , Loc, loc, loc, loc, loc, loc, loc + 1); );} Retornar strlist;}/*** Converterá expressões de expressões de infix em expressões de sufixo (polonês)* @param list list de expressões analisadas* @return string [] Expressão convertida String Array*/public string [] Midtoend (Lista Lista MID) {Pilha EMBL = NOVA PATELA (); /if (Sign.ContainsKey (Curstr)) {/* Se a pilha de símbolos estiver vazia ou o símbolo for (*/if (0 == EMBL.SIZE () || "(". EMBL.PUSH (Curstr);} else {/*Se o símbolo for) A pilha de símbolos precisa estar fora da pilha até que um (até agora*/if (")". Iguals (Curstr)) {while (!! "(" (".equals (((string) EMBL.PEEK ())) {if (0> = EMBL.SIZE ()) {return null;} resultado.push (EMBL.POP ()));} EMBL. pop ();} else {int p1 = Integer.parseint ((string) signo.get (curstr)); A prioridade da prioridade do personagem atual do personagem atual do que o símbolo superior da pilha*/if (p1> p2) {EMBL.PUSH (Curstr);} else {while (p1 <= p2 || EMBL.SIZE ()> 0) {Resultado.push (EMBL .pop ()); .push (curstr); (); RET;}/*** Expressão do sufixo da análise, retorne o resultado da operação correspondente* @param string [] endstr a expressão do sufixo convertido* @return Objeto retornar o resultado da operação Se a expressão estiver incorreta, imprima "Erro de entrada"*/objeto público Calcule (String [] ENDST) {int len = endstr.Length; .ContainsKey (endstr [i]))) {) {Try i]));} Catch (NumberFexception Ex) {Ex.PrintStackTrace (); [i]);}} if (1 == calc.size ()) {return calc.pop ();} else {return "Erro de entrada";}/*** Realize a função de computação subjacente* @param duplo p1 Número 1 * @param duplo p1 número 2 * @param string operador +-/ * */public Double SimpleCalc (duplo P1, P2 duplo, operador de sequência) {switch (oper.char em (0)) {{case ' +' : Retorno P1 + P2; /Coloque o void estático principal (string [] args) {calcularxp Ce = novo calcularexp (); ) CE.Calculate (Ce.midtoEnd (Ce.Transstr (TMP)); valor duplo = 0; ;A seguir, é apresentado um suplemento de outros internautas
A idéia de código é calcular cada unidade de cálculo mínimo por meio de julgamento regular. A seguir, o código:
importar java.math.bigdecimal; importar java.util.regex.matcher; importar java.util.regex.pattern;/** * Class de ferramenta da calculadora * @author shuqi * @date 2015-7-23 * @versão desde 1.0 * /Public classe calculatorutil {public static bigdecimal aritmética (string exp) {if (! Exp.matic ("// d+") {string resultado = parseexp (exp) .re placell ("[// [//]]" "" "," ""); Retorna novos bigdecimal (resultado);} else {retorna novo bigdecimal (exp);}/*** unidade de contagem mínima ***/private string = "^^ (// d+((// d+(// d+//. // d+)) izing (//.//d+)?)|(////-//d+(//.//d+)??///201S))$ ";/***Operação sem colchetes*/String estática privada notarentesses =" ^^ // (//)]+$ ";/*** MOTELICAÇÃO COM MAIS COMPLAÇÃO ou Método de divisão*/String privada Prioroperatorexp =" ((// D+(//.// D+)? /d+)?) |. ) || -1 (///// d+ // d+ off .//d+))|-1 (////-/d+ (// // d+)? //////////// /////////////// dmi))) ")") ")"; ** Analise e calcule as quatro expressões de operações, por exemplo: 2+((3+4) * 2-22)/2 * 3 * @param expressão * @return */parseexp de sequência estática privada (expressão de string) {// O método entra e substitui o espaço primeiro e remove o número () em ambos os lados da operação expressão = expressão.Replaceall ("// s +", "") .Replaceall ("^// ([[^// (/)]+) //) $ "," $ 1 "); // cálculo mínimo de expressão se (expressão.matches (minexp)) {string resultado = calcular (expressão); retorna duplo.parseDouble (resultado)> = 0? Resultado: "[" Result+"]"; ); .Matcher (expressão); Calcule quatro operações com padrão de colchetes = padrão.compile (minparenteses); , parseexp (tempminexp)); = Exp.Replaceall ("[// [/]" "," "); número da sequência [] = exp.replacefirst (" (// d) [[// d) [["//+//-/// /*//] "," $ 1 "). Split (", ","); Operador = exp.replacefirst ("^^. = número1.add (número2); (número2); Redond_celing);O código era originalmente um blog, mas o código não tinha comentários e havia um bug. Tome uma nota aqui para facilitar o uso mais tarde
Além disso, para expressar respeito ao autor original, o código original está anexado
/*** Cálculo de expressão de quatro operação* @author Penli**/public class Arithmetic {public static void main (string args []) {System.out.println (aritmético ("2.2+ ((3+4)* 2 - 22) /2*3.2 "));} public static duplo aritmético (string exp) {string resultado = parseexp (exp) .replaceall (" [// [//] "," "); retorna duplo.parsed ouble (resultado); expressão) {// string numberreg = "^((?! 0) // d+(//.// d+(? <! 0))?) | (0 //.// d+(? <! 0) ) $ "; expressão = expressão.Replaceall (" // s+"," ") .replaceall ("^// ((.+) //) $ "," $ 1 "); string checkexp =" // d " ; //-//*///body(//d+(//.//d+)?)|(/////-/d+(//.//d+)??//]))) $ "; // O cálculo da expressão mínima if (Expression.Matches (minexp)) {String res) ult+"] ";} // calcule quatro operações sem colchetes string noparentesses ="^[^// (//)]+ $ "; String prioroperatorexp =" (((// d+(//.// d+)?) | (//[//-// d+(//.// D+)? //] [/// *///] (// d+(//.// d+)?) | /]) "; String operatorexp =" ((// d+(//.// d+)?) | (// [// [// -// d+(//.// D+)? //] )) [//+//-] (// d+(//.// d+)?) | if (Expression.Matches (não)) {Pattern Patt = Pattern.compile (PrioroPeratexp); );} Else {ompile (Operatorexp); );} // Calcule quatro dos parênteses computando String minparenteses = "// ([^// (/)]+//)"; ; param exp * @return */string estática pública Calcular (string exp) {exp = exp.replaceall ("[// [//]]", ""); d) [//+//-//*///] "," $ 1 "). Split (", "); BigDecimal Number1 = novo BigDecimal (número [0]); número [1]); Resultado bigdecimal = null; Operador)) {resultado = número1.add (número2);} else if ("-". Equals (operador)) {resultado = número1.subtract (número2);} else " *" = Number1.Multiply (número2);} eliminação se ("/".Finalmente, compartilharei com você o método de implementação de um internautas.
Importar java.util.stack; IS: Usando o operador atualmente obtido com os fãs de primeira linha do Pristack: se for mais alto, ele será calculado primeiro e o colocará na parte superior da pilha; de operações; * Se for menor, o mesmo é verdadeiro. Cada prioridade '('> ' *' = '/'> '+' = '-' '') ' * * */public class Operation {private Stack <Acleda> pristack = new Stack <); Stack STACK STACK <TEGER> NUMSTACK = NOVA PADELA <TEGER> (); Verificação de verificação)* @param str precisa executar expressão técnica* @return Resultados de cálculo*/ public em (string str) {// 1. Determine se existem caracteres ilegais na string temp; Para analisar a string. StringBuffer (). Appender (str); // usado para salvar e melhorar a eficiência enquanto (string.length ()! = 0) {temp = string.substring (0, 1); / Juiz Temp. tempnum if (! "" ". Equals (tempnum.toString ())) {// Quando o primeiro símbolo da expressão é o suporte int num = integer.parseint (tempnum.tostring ()); delete (0, tempnum. Length ());} // Use o operador atualmente obtido a ser priorizado com o símbolo de cálculo de empilhamento: se for maior, será calculado primeiro, colocado na parte superior da pilha; Os elementos superiores da pilha estão fora da pilha e removem o número de operações de operação; // determinar a prioridade do símbolo de computação atual e o elemento superior da pilha, retirar os elementos e calcular (porque a prioridade pode ser menor que o elemento superior da pilha, também é menor que o segundo elemento, etc. ., você precisa usar um julgamento do ciclo). .pop (); = B + A; resultado); o resultado operacional no número operacional de Numstack. Caractere (temp.charat (0))); no suporte para calcular e remover os parênteses propack.pop (); Depois de receber o número de dígitos, leia o número de leituras (quando não é um único dígito)} retorna numStack.pop (); Private Boolean Isnum (String temp) {retorna temp.matches ("[0-9]");} / ** * Compare os símbolos operacionais atuais e os símbolos de operação do elemento superior da pilha. da pilha, retorna true, caso contrário, é necessário retornar falsa * * @param str. ()) {// Quando está vazio, é obviamente a menor prioridade. , ')' Não pode ser o topo da pilha. if (last == '(') {return true;} switch (str) {case '#': return false; // o caractere final "; case ')': // ')') 'a menor prioridade, retornar false; ') Retornar verdadeiro; ew operar ();