最基本的运算符表达式
我看这个比较好，可以很简单的就处理了运算符表达式，下面关注的其实就是一点，就是符号栈，就是下面的operatorStack栈，当往operatorStack栈里面添加符号的时候，只要添加的符号的运算等级比operatorStack栈顶的运算符等级低，那么就把operatorStack栈顶的运算符弹出来，进行运算，如果添加的符号的运算等级比operatorStack栈顶的运算符等级高，那么就直接添加
package com.ma.first;
import java.util.*;
/**
* Created by chenjiabing on 17-5-13.
*/
/**主要的思想如下：
* 程序从左到右的扫描表达式，提取出操作数，操作符，以及括号
* 如果提取的项是你操作数直接将其压入operandStack栈中
* 如果提取的项是+，-运算符，处理operatorStack栈定中的所有运算符，处理完之后将提取出的运算符压入栈中
* 如果提取的项是*,/运算符，处理栈顶的所有*,/运算符，如果此时的栈顶的运算符是+，-那么直接入栈，处理完之后将提取出的运算符入栈
* 如果提取的是'(',那么直接压入operatorStack栈中
* 如果提取的是')',重复处理来自operatorStack栈顶的运算符，直到看到栈顶的'('
*/
public class Hello {
//这个函数的作用就是使用空格分割字符串，以便后面使用分割函数使得将字符串分割成数组
public String insetBlanks(String s) {
String result = "";
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(' || s.charAt(i) == ')' ||
s.charAt(i) == '+' || s.charAt(i) == '-'
|| s.charAt(i) == '*' || s.charAt(i) == '/')
result += " " + s.charAt(i) + " ";
else
result += s.charAt(i);
}
return result;
}
public int evaluateExpression(String expression) {
//数字栈
Stack<Integer> operandStack = new Stack<>();
//符号栈
Stack<Character> operatorStack = new Stack<>();
expression = insetBlanks(expression);
String[] tokens = expression.split("\\s+");
for (String token : tokens) {
if (token.length() == 0) //如果是空格的话就继续循环，什么也不操作
continue;
//如果是加减的话，因为加减的优先级最低，因此这里的只要遇到加减号，无论操作符栈中的是什么运算符都要运算
else if (token.charAt(0) == '+' || token.charAt(0) == '-') {
//当栈不是空的，并且栈中最上面的一个元素是加减乘除的人任意一个
while (!operatorStack.isEmpty()&&(operatorStack.peek() == '-' || operatorStack.peek() == '+' || operatorStack.peek() == '/' || operatorStack.peek() == '*')) {
processAnOperator(operandStack, operatorStack); //开始运算
}
operatorStack.push(token.charAt(0)); //运算完之后将当前的运算符入栈
}
//当前运算符是乘除的时候，因为优先级高于加减，因此要判断最上面的是否是乘除，如果是乘除就运算，否则的话直接入栈
else if (token.charAt(0) == '*' || token.charAt(0) == '/') {
while (!operatorStack.isEmpty()&&(operatorStack.peek() == '/' || operatorStack.peek() == '*')) {
processAnOperator(operandStack, operatorStack);
}
operatorStack.push(token.charAt(0)); //将当前操作符入栈
}
//如果是左括号的话直接入栈，什么也不用操作,trim()函数是用来去除空格的，由于上面的分割操作可能会令操作符带有空格
else if (token.trim().charAt(0) == '(') {
operatorStack.push('(');
}
//如果是右括号的话，清除栈中的运算符直至左括号
else if (token.trim().charAt(0) == ')') {
while (operatorStack.peek() != '(') {
processAnOperator(operandStack, operatorStack); //开始运算
}
operatorStack.pop(); //这里的是运算完之后清除左括号
}
//这里如果是数字的话直接如数据的栈
else {
operandStack.push(Integer.parseInt(token)); //将数字字符串转换成数字然后压入栈中
}
}
//最后当栈中不是空的时候继续运算，知道栈中为空即可
while (!operatorStack.isEmpty()) {
processAnOperator(operandStack, operatorStack);
}
return operandStack.pop(); //此时数据栈中的数据就是运算的结果
}
//这个函数的作用就是处理栈中的两个数据，然后将栈中的两个数据运算之后将结果存储在栈中
public void processAnOperator(Stack<Integer> operandStack, Stack<Character> operatorStack) {
char op = operatorStack.pop(); //弹出一个操作符
int op1 = operandStack.pop(); //从存储数据的栈中弹出连个两个数用来和操作符op运算
int op2 = operandStack.pop();
if (op == '+') //如果操作符为+就执行加运算，其他类似
operandStack.push(op1 + op2);
else if (op == '-')
operandStack.push(op2 - op1); //因为这个是栈的结构，自然是上面的数字是后面的，因此用op2-op1，除法也一样
else if (op == '*')
operandStack.push(op1 * op2);
else if (op == '/')
operandStack.push(op2 / op1);
}
public static void main(String[] args) {
Hello hello = new Hello();
String expression = "1- 2*3*4";
int data = hello.evaluateExpression(expression);
System.out.println(data);
}
}
参考连接：
https://blog.csdn.net/qq_34162294/article/details/72454668
优化一：使用解释器模式实现“新符号的添加”
什么意思呢，因为在开发的时候，可能会出现一个新的符号，这个符号的运算表达式是未知的，而且这个符号的运算优先级也是未知的，此时就需要我们实现这个功能，此时的代码如下所示
首先是Node节点，符号，具体的值，左括号，右括号等都直接或者间接实现了Node接口，下面的getLevel()是返回符号的等级，然后getOperator()返回符号的具体值
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:12
*/
public interface Node {
/**
*定义接口里面的算法规则，符号，具体的值，左括号，右括号等都直接或者间接实现了这个interpret方法
* @return
*/
int interpret();
int getLevel();
}
然后是解释器模式里面的非终结符表达式，这里就是符号抽象类，AbstractSymbolNode抽象类实现了Node接口，然后因为它是非终结符表达式，所以他存在左节点和有节点(就比如(3+2)*5+8/(5+5)表达式，那么(3+2)*5就可以叫做左节点，8/(5+5)就可以叫做有节点，然后在比如3+2，那么3就可以称为一个左节点，2可以称为右节点)，
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:13
*/
public abstract class AbstractSymbolNode implements Node {
protected Node left;
protected Node right;
public AbstractSymbolNode(){}
public AbstractSymbolNode(Node left, Node right) {
this.left = left;
this.right = right;
}
}
然后就是加符号继承AbstractSymbolNode，就是下面的PlusNode类，此时的加符号的等级是1
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 11:20
* 加法
*/
public class PlusNode extends AbstractSymbolNode {
public PlusNode(Node left, Node right){
super(left,right);
}
public PlusNode(){}
public final static int LEVEL=1;
@Override
public int interpret(){
return super.left.interpret() + super.right.interpret();
}
@Override
public int getLevel() {
return LEVEL;
}
}
然后就是减符号继承AbstractSymbolNode，就是下面的MinusNode类，此时的加符号的等级是1
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 11:19
* 减法
*/
public class MinusNode extends AbstractSymbolNode {
public MinusNode(Node left, Node right){
super(left,right);
}
public MinusNode(){
}
public final static int LEVEL=1;
@Override
public int interpret(){
return super.left.interpret() - super.right.interpret();
}
@Override
public int getLevel() {
return LEVEL;
}
}
然后是乘法类，乘法符号继承AbstractSymbolNode，就是下面的MultiplyNode类，此时的加符号的等级是2
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:15
* 乘法
*/
public class MultiplyNode extends AbstractSymbolNode {
public MultiplyNode(Node left, Node right) {
super(left, right);
}
public MultiplyNode(){}
public final static int LEVEL=2;
@Override
public int interpret() {
return left.interpret() * right.interpret();
}
@Override
public int getLevel() {
return LEVEL;
}
}
然后是除类，除法符号继承AbstractSymbolNode，就是下面的DivisionNode类，此时的加符号的等级是2
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:15
* 除法
*/
public class DivisionNode extends AbstractSymbolNode {
public DivisionNode(){};
public DivisionNode(Node left, Node right){
super(left,right);
}
public final static int LEVEL=2;
@Override
public int interpret(){
return super.left.interpret() / super.right.interpret();
}
@Override
public int getLevel() {
return LEVEL;
}
}
然后是解释器模式里面的终结符表达式，就是下面的这个类抽象类AbstractOtherNode，
AbstractOtherNode抽象类实现了Node接口，然后因为它是终结符表达式，所以他没有左右节点，此时就只有一个value值，就是这个终结符的值(什么意思呢，比如(3+2)*5这个表达式，那么此时的value就是指这个表达式里面的3,2,5,(,)等符号)，然后AbstractOtherNode我给的getLevel()返回值都是-1，因为终结符表达式不需要这个等级的概念(这个自己参悟吧)
package com.ma.third;
public abstract class AbstractOtherNode implements Node {
private String value;
public AbstractOtherNode(String value) {
this.value = value;
}
@Override
public int getLevel() {
return -1;
}
public String getValue() {
return value;
}
}
然后就是值类，就是下面这一个ValueNode类，这个类是是实现了AbstractOtherNode抽象类的，这里的interpret()方法的返回值就是值类的具体值，然后这里我给具体值的等级是-1(AbstractOtherNode抽象类里面有)，
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:13
* 具体的值，这个也实现了Node接口
*/
public class ValueNode extends AbstractOtherNode {
public ValueNode(String value) {
super(value);
}
@Override
public int interpret() {
return Integer.parseInt(super.getValue());
}
}
然后就是左括号类，就是下面这一个LeftNode类，这个类是是实现了AbstractOtherNode抽象类的，这里的interpret()方法的返回值就是-1(这是因为左括号和右括号不会调用interpret方法，你就把左括号和有括号当成一个特殊的符号就行了)，然后这里我给左括号的等级是-1(AbstractOtherNode抽象类里面有)，
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 17:01
* 左括号
*/
public class LeftNode extends AbstractOtherNode {
public LeftNode(String value) {
super(value);
}
@Override
public int interpret() {
return -1;
}
}
然后就是右括号类，就是下面这一个RightNode类，这个类是是实现了AbstractOtherNode抽象类的，这里的interpret()方法的返回值就是-1(这是因为左括号和右括号不会调用interpret方法，你就把左括号和有括号当成一个特殊的符号就行了)，然后这里我给右括号的等级是-1(AbstractOtherNode抽象类里面有)，
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 17:02
* 右括号
*/
public class RightNode extends AbstractOtherNode {
public RightNode(String value) {
super(value);
}
@Override
public int interpret() {
return -1;
}
}
然后就是运算符表达式Calculator，这个和上面的最简单的运算符表达式很类似，就是符号栈里面的优先级判断变成符号等级的判断了：当往operatorStack栈里面添加符号的时候，只要添加的符号的运算等级比operatorStack栈顶的运算符等级低，那么就把operatorStack栈顶的运算符弹出来，进行运算，如果添加的符号的运算等级比operatorStack栈顶的运算符等级高，那么就直接添加
package com.ma.third;
import com.google.common.collect.Maps;
import java.util.HashMap;
import java.util.Objects;
import java.util.Stack;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:16
*/
public class Calculator {
private Calculator() {
}
private static Calculator calculator = new Calculator();
public static Calculator getCalculator() {
return calculator;
}
private static HashMap<Character, Node> hashMap = Maps.newHashMap();
static {
hashMap.put('/', new DivisionNode());
hashMap.put('-', new MinusNode());
hashMap.put('*', new MultiplyNode());
hashMap.put('+', new PlusNode());
hashMap.put('(', new LeftNode("("));
hashMap.put(')', new RightNode(")"));
}
/**
* 这个函数的作用就是使用空格分割字符串，以便后面使用分割函数使得将字符串分割成数组
*
* @param s
* @return
*/
public String insetBlanks(String s) {
String result = "";
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(' || s.charAt(i) == ')' ||
s.charAt(i) == '+' || s.charAt(i) == '-'
|| s.charAt(i) == '*' || s.charAt(i) == '/') {
result += " " + s.charAt(i) + " ";
} else {
result += s.charAt(i);
}
}
return result;
}
/**
* 取出来表达式里面的每一个字符，把数字放到一个operandStack，把符号放入到operatorStack栈里面，并且进行运算，返回值就是
* 运算结果
*
* @param expression
* @return
*/
public int evaluateExpression(String expression) {
Stack<Node> operandStack = new Stack<>();
Stack<Character> operatorStack = new Stack<>();
expression = insetBlanks(expression);
String[] tokens = expression.split("\\s+");
for (String token : tokens) {
//如果是空格的话就继续循环，什么也不操作
if (token.length() == 0) {
continue;
//如果添加的运算符等级是1
} else if (Objects.nonNull(hashMap.get(token.charAt(0))) && hashMap.get(token.charAt(0)).getLevel() == 1) {
//当栈不是空的，并且运算符栈中最上面的一个元素是等级大于0的任意一个
while (!operatorStack.isEmpty() && hashMap.get(operatorStack.peek()).getLevel() > 0) {
processAnOperator(operandStack, operatorStack);
}
//运算完之后将当前的运算符入栈
operatorStack.push(token.charAt(0));
//当添加的运算符等级是2
} else if (Objects.nonNull(hashMap.get(token.charAt(0))) && hashMap.get(token.charAt(0)).getLevel() == 2) {
while (!operatorStack.isEmpty() && hashMap.get(operatorStack.peek()).getLevel() > 1) {
processAnOperator(operandStack, operatorStack);
}
//将当前操作符入栈
operatorStack.push(token.charAt(0));
//如果是左括号的话直接入栈，什么也不用操作,trim()函数是用来去除空格的，由于上面的分割操作可能会令操作符带有空格
} else if (token.trim().charAt(0) == '(') {
operatorStack.push(token.trim().charAt(0));
//如果是右括号的话，清除栈中的运算符直至左括号
} else if (token.trim().charAt(0) == ')') {
while (!operatorStack.peek().equals('(')) {
//开始运算
processAnOperator(operandStack, operatorStack);
}
//这里的是运算完之后清除左括号
operatorStack.pop();
} else {
//将数字字符串转换成数字然后压入栈中
operandStack.push(new ValueNode(token));
}
}
//最后当栈中不是空的时候继续运算，直到栈中为空即可
while (!operatorStack.isEmpty()) {
processAnOperator(operandStack, operatorStack);
}
//然后调用最外层的node调用interpret来计算数据
return operandStack.pop().interpret();
}
/**
* 这个函数的作用就是处理栈中的两个数据，然后将栈中的两个数据运算之后将结果存储在栈中
*
* @param operandStack
* @param operatorStack
*/
public void processAnOperator(Stack<Node> operandStack, Stack<Character> operatorStack) {
//弹出一个操作符
Character op = operatorStack.pop();
//从存储数据的栈中弹出连个两个数用来和操作符op运算
Node op1 = operandStack.pop();
Node op2 = operandStack.pop();
switch (op) {
//如果操作符为+就执行加运算
case '+':
operandStack.push(new PlusNode(op1, op2));
break;
//因为这个是栈的结构，自然是上面的数字是后面的，因此用op2在前，op1在后
case '-':
operandStack.push(new MinusNode(op2, op1));
break;
case '*':
operandStack.push(new MultiplyNode(op1, op2));
break;
case '/':
operandStack.push(new DivisionNode(op1, op2));
break;
default:
break;
}
}
}
然后是客户端Client
package com.ma.third;
/**
* @author ma\_qiankun
* @date 2019/6/6 10:17
*/
public class Client{
public static void main(String[] args){
String statement = "(3 + 2 * 2*( 5 + 7 )+(3+6)*2)*3+2";
Calculator calculator = Calculator.getCalculator();
int result = calculator.evaluateExpression(statement);
System.out.println(statement + " = " + result);
}
}
结果如下所示
能看到这里的同学，就帮忙右上角点个赞吧，Thanks♪(･ω･)ﾉ
扫一扫
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
