实现简单的四则运算-Java
最近上网查了一下,竟然没有找到用Java编写的四则运算的代码,就小写了一下.如有问题请大家反馈.
1.说明
代码只是实现了简单的四则运算,支持+,-,*,/,(,) 只能计算出正确的表达式的值,没有对非法表达式进行校验.
2.实现方法
第一步:将输入的字符串转换为List,主要是用来将String转换为原子:数值/运算符/括号
public List transStr(String str)
{
List strList = new ArrayList();
/* 获取提出数据的符号串 */
String tmp = str.replaceAll(" \\d*", "");
/* 记录当前的运算符 */
String curLet = null;
/* 记录tmp字符串中第一个运算符的位置 */
int loc = 0;
/* 符号串长度 */
int len = tmp.length();
for (int i = 0; i < len; i++)
{
curLet = tmp.substring(i, i + 1);
loc = str.indexOf(curLet);
/* 如果当前处理字符为( 或者 ) */
{
List strList = new ArrayList();
/* 获取提出数据的符号串 */
String tmp = str.replaceAll(" \\d*", "");
/* 记录当前的运算符 */
String curLet = null;
/* 记录tmp字符串中第一个运算符的位置 */
int loc = 0;
/* 符号串长度 */
int len = tmp.length();
for (int i = 0; i < len; i++)
{
curLet = tmp.substring(i, i + 1);
loc = str.indexOf(curLet);
/* 如果当前处理字符为( 或者 ) */
if (!"".equals(str.substring(0, loc).trim()))
{
strList.add(str.substring(0, loc).trim());
}
strList.add(str.substring(loc, loc + 1));
str = str.substring(loc + 1);
}
if (0 < str.length())
{
strList.add(str.trim());
}
return strList;
}
{
strList.add(str.substring(0, loc).trim());
}
strList.add(str.substring(loc, loc + 1));
str = str.substring(loc + 1);
}
if (0 < str.length())
{
strList.add(str.trim());
}
return strList;
}
第二步: 将原来的中缀表达式转换为后缀表达式,在四则运算中,后缀表达式是最方便计算的
public String[] midToEnd(List midList)
{
Stack embl = new Stack();
Stack result = new Stack();
Iterator it = midList.iterator();
String curStr = null;
while (it.hasNext())
{
curStr = (String) it.next();
/* 确认是否式字符串 */
if(sign.containsKey(curStr))
{
/* 如果符号栈为空 或者符号为( */
if (0 == embl.size() || "(".equals(curStr))
{
embl.push(curStr);
}
else
{
/*如果符号为) 符号栈需要出栈,直到匹配一个(为止 */
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));
int p2 = Integer.parseInt((String) sign.get(embl.peek()));
/* 如果当前字符的优先级大于栈顶符号的优先级 */
if (p1 > p2)
{
embl.push(curStr);
}
else
{
while (p1 <= p2 || embl.size() > 0)
{
result.push(embl.pop());
if(0 == embl.size())
{
break;
}
p2 = Integer.parseInt((String) sign.get(embl.peek()));
}
embl.push(curStr);
}
}
}
}
else
{
result.push(curStr);
}
}
while (0 < embl.size())
{
result.push(embl.pop());
}
int len = result.size();
String[] ret = new String[len];
for (int i = 0; i < len; i++)
{
ret[len - i - 1] = (String) result.pop();
}
return ret;
}
{
Stack embl = new Stack();
Stack result = new Stack();
Iterator it = midList.iterator();
String curStr = null;
while (it.hasNext())
{
curStr = (String) it.next();
/* 确认是否式字符串 */
if(sign.containsKey(curStr))
{
/* 如果符号栈为空 或者符号为( */
if (0 == embl.size() || "(".equals(curStr))
{
embl.push(curStr);
}
else
{
/*如果符号为) 符号栈需要出栈,直到匹配一个(为止 */
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));
int p2 = Integer.parseInt((String) sign.get(embl.peek()));
/* 如果当前字符的优先级大于栈顶符号的优先级 */
if (p1 > p2)
{
embl.push(curStr);
}
else
{
while (p1 <= p2 || embl.size() > 0)
{
result.push(embl.pop());
if(0 == embl.size())
{
break;
}
p2 = Integer.parseInt((String) sign.get(embl.peek()));
}
embl.push(curStr);
}
}
}
}
else
{
result.push(curStr);
}
}
while (0 < embl.size())
{
result.push(embl.pop());
}
int len = result.size();
String[] ret = new String[len];
for (int i = 0; i < len; i++)
{
ret[len - i - 1] = (String) result.pop();
}
return ret;
}
第三步:将解析后缀表达式,返回计算的最终结果
/**
* 解析后缀表达式,返回对应的运算结果
* @param String[] endStr 转换后的后缀表达式
* @return Object 返回运算结果 如果表达式有误直接打印"Input Error"
*/
public Object calculate(String[] endStr)
{
int len = endStr.length;
Stack calc = new Stack();
double p2;
double p1;
for (int i = 0; i < len; i++)
{
if (sign.containsKey(endStr[i]))
{
try
{
p2 = Double.parseDouble((String) calc.pop());
p1 = Double.parseDouble((String) calc.pop());
calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));
}
catch(NumberFormatException ex)
{
ex.printStackTrace();
return "Input Error";
}
catch(Exception ex)
{
ex.printStackTrace();
return "Input Error";
}
}
else
{
calc.push(endStr[i]);
}
}
if (1 == calc.size())
{
return calc.pop();
}
else
{
return "Input Error";
}
}
/**
* 实现底层的运算函数
* @param double p1 数字1
* @param double p1 数字2
* @param String oper 运算符 +-/*
*/
public double simpleCalc(double p1, double p2, String oper)
{
switch(oper.charAt(0))
{
case '+':
return p1 + p2;
case '-':
return p1 - p2;
case '*':
return p1 * p2;
case '/':
return p1 / p2;
default:
return p1;
}
}
* 解析后缀表达式,返回对应的运算结果
* @param String[] endStr 转换后的后缀表达式
* @return Object 返回运算结果 如果表达式有误直接打印"Input Error"
*/
public Object calculate(String[] endStr)
{
int len = endStr.length;
Stack calc = new Stack();
double p2;
double p1;
for (int i = 0; i < len; i++)
{
if (sign.containsKey(endStr[i]))
{
try
{
p2 = Double.parseDouble((String) calc.pop());
p1 = Double.parseDouble((String) calc.pop());
calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));
}
catch(NumberFormatException ex)
{
ex.printStackTrace();
return "Input Error";
}
catch(Exception ex)
{
ex.printStackTrace();
return "Input Error";
}
}
else
{
calc.push(endStr[i]);
}
}
if (1 == calc.size())
{
return calc.pop();
}
else
{
return "Input Error";
}
}
/**
* 实现底层的运算函数
* @param double p1 数字1
* @param double p1 数字2
* @param String oper 运算符 +-/*
*/
public double simpleCalc(double p1, double p2, String oper)
{
switch(oper.charAt(0))
{
case '+':
return p1 + p2;
case '-':
return p1 - p2;
case '*':
return p1 * p2;
case '/':
return p1 / p2;
default:
return p1;
}
}
第四步:运算符的优先级放在了缓存中进行提取
private static HashMap sign = new HashMap();
/* 将运算符的优先级放入到缓存处理 */
public CalculateExp()
{
sign.put(")", "3");
sign.put("*", "2");
sign.put("/", "2");
sign.put("+", "1");
sign.put("-", "1");
sign.put("(", "0");
}
/* 将运算符的优先级放入到缓存处理 */
public CalculateExp()
{
sign.put(")", "3");
sign.put("*", "2");
sign.put("/", "2");
sign.put("+", "1");
sign.put("-", "1");
sign.put("(", "0");
}
这里只是抛砖引玉,如果大家发现有什么好的方法请直接回复,
转载于:https://blog.51cto.com/guoguo/139802