最近学习到后缀表达式,于是基于后缀表达式的思想,写了一个四则运算解释器,输入字符串类型的四则运算表达式,可以直接得到结果,支持括号嵌套. 
实现时主要考虑以下两点:

  • 字符串中运算符和数字分离
  • 运算符优先级
  • 括号的嵌套

  1. 运算符和数字分离:可以考虑用字符串数组存储
  2. 关于运算符优先级,最开始的想法是将乘除法看作一类,加减法看作一类,乘除法的优先级大于加减法,相同类型的运算符按照从左到右顺序依次计算.
  3. 括号的嵌套:由于括号内部本身也是表达式,因此可以使用递归处理,但重点在于括号的配对,由于使用递归,所以希望获取最大的嵌套单元.

具体实现:

首先实现运算符识别的代码,判断一个字符是否为运算符:

public static boolean opjudge(char c) {
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
return true;
else
return false;
}

然后实现字符串表达式转为字符串数组, 由于要求输入的字符串运算符和数字之间没有空格,所以直接拆分不方便,而且运算符和数字的数目不确定,因此先使用ArrayList存储,然后再转成字符串数组,主要方法是遍历字符串中每一个字符并判断是否为运算符,如果是运算符,则直接将运算符转为字符串加入ArrayList,如果不是,则从此位置继续查找到下一个运算符出现的位置,两个位置之间即为操作数,使用substring截取字符串存入Arraylist,具体实现如下:

public static String[] convert(String s) {
ArrayList<String> arrayList = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
if (!opjudge(s.charAt(i))) {
int j = i;
while ((i < s.length()) && !opjudge(s.charAt(i)))
i++;
arrayList.add(s.substring(j, i));
i--;
} else
arrayList.add(String.valueOf(s.charAt(i)));
} return arrayList.toArray(new String[arrayList.size()]); }

然后对运算符进行分类和分级,加减法视作一类,乘除法视作一类,乘除法优先级高于加减法:

 public static int opvalue(String s) {
switch (s) {
case "+":
case "-":
return 1;
case "*":
case "/":
return 2;
default:
return -1;
} }

运算符优先级的比较,左边大于右边则返回true,( 两个运算符相等返回false)

 public static boolean opcompare(String s1, String s2) {
if (opvalue(s1) > opvalue(s2))
return true;
else {
return false;
} }

括号内字符串的获取: 
由于括号都是成对出现,要从左至右获取第一个最长的括号表达式,则从左至右遍历字符串时,当右括号 ‘)’ 出现的数目等于左括号’(’ 时,即为所求,此处使用计数器实现,返回的是字符串中从k位置(第k个元素,一个数字算一个元素 )开始第一个带完整括号的子串,比如输入bracketGet(“(8-(2+3))*2+(5+7)*3”,0),返回8-(2+3):

public static String bracketGet(String s, int k) {
int m=0;
int i;
String[] arr=convert(s);
for(i=k;i<arr.length;i++){
if(arr[i].equals("(")){
m++;
continue;
}
if(arr[i].equals(")")){
m--;
if(m==0)
break;
else
continue;
} }
StringBuilder sb=new StringBuilder();
for(int j=k+1;j<i;j++){
sb.append(arr[j]);
}
return sb.toString();
}

以上都是需要用到的配件,下面将利用上面写好的函数实现四则运算字符串的解析和运算,基本思想是使用两个栈,一个存储数字,一个存储运算符,先考虑没有括号的简单情况: 
遍历字符串数组: 
1.当前元素为操作数时,入数字栈 
2.当前元素为运算符时:

  • 如果运算符栈为空,则入运算符栈
  • 如果运算符栈不空,则比较当前运算符和栈顶运算符优先级(按照之前定义的优先级,乘除大于加减,乘除相同,加减相同):如果当前运算符优先级大于栈顶运算符,则当前运算符入栈;反之,如果当前运算符优先级等于或小于栈顶运算符,则将栈顶运算符出栈,同时数字栈中出栈两个数字参与运算,结果压入数字栈中,然后当前运算符入栈;
  • 最后将运算符栈中所有元素依次出栈,数字栈中相应将数字出栈参与运算得到结果并压入栈中;
  • 最后返回数字栈中栈顶元素即为表达式结果.
  • 有括号时括号内的运算步骤同上,可以获取括号内部的字符串,使用递归计算; 
    代码如下:
  • public static int caculate(String formula) {
    String[] arr = convert(formula);
    Stack<Integer> val = new Stack<>();
    Stack<String> op = new Stack<>(); for (int i = 0; i < arr.length; i++) {
    if (arr[i].equals("(")) {
    val.push(caculate(bracketGet(formula, i)));//递归计算括号内部的值,并将该值入栈
    i = i + bracketGet(formula, i).length() + 1;//括号串所在的位置遍历过,i需要跳过该段
    } else {
    if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    if (op.isEmpty())
    op.push(arr[i]);
    else if (opcompare(arr[i], op.lastElement())) {
    op.push(arr[i]);
    } else { switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    break;
    case "-":
    int c = val.pop();
    int d = val.pop();
    val.push(d-c);//减法,pop的顺序从右至左,所以需要先取出元素
    break;
    case "*":
    val.push(val.pop() * val.pop());
    break;
    case "/":
    int a = val.pop();
    int b = val.pop();
    val.push(b / a);//同减法
    break;
    default:
    break;
    }
    op.push(arr[i]);
    }
    } else
    val.push(Integer.parseInt(arr[i]));
    }
    }
    while (!op.isEmpty()) {
    switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    break;
    case "-":
    int c = val.pop();
    int d = val.pop();
    val.push(d-c);
    break;
    case "*":
    val.push(val.pop() * val.pop());
    break;
    case "/":
    int a = val.pop();
    int b = val.pop();
    val.push(b / a);
    break;
    default:
    break;
    }
    } return val.pop();
    }
    System.out.println(caculate("(((8-(2+3))*2+(5+7)*3))"));
    输出:42 正确

    以上实现是使用int类型,除法可能会不准确,改为double会准确


    后面又发现上面的实现方法仍然有冗余之处,下面是改进的代码,主要是优化了运算符的优先级,依次为 除法 乘法 减法 加法 依次降低, 遍历到运算符时,优先级高才入栈, 否则将栈中运算符出栈参与运算,直到栈空或 栈顶运算符优先级低于遍历到的运算符,才将该运算符入栈. 
    主要改动的是opjudge(),opcompare(), caculate()中少量改动,其余代码同上; 
    具体代码如下:

  • public static int opvalue2(String s) {
    switch (s) {
    case "+":
    return 1;
    case "-":
    return 2;
    case "*":
    return 3;
    case "/":
    return 4;
    default:
    return -1;
    }
    }
    public static boolean opcompare2(String s1, String s2) {
    if (opvalue2(s1) >= opvalue2(s2))
    return true;
    else {
    return false;
    }
    }
    public static double caculate2(String formula) {
    String[] arr = convert(formula);
    Stack<Double> val = new Stack<>();
    Stack<String> op = new Stack<>(); for (int i = 0; i < arr.length; i++) {
    if (arr[i].equals("(")) {
    val.push(caculate2(bracketGet(formula, i)));
    i = i + bracketGet(formula, i).length() + 1;
    } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
    switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    continue;
    case "-":
    double c = val.pop();
    double d = val.pop();
    val.push(d - c);
    continue;
    case "*":
    val.push(val.pop() * val.pop());
    continue;
    case "/":
    double a = val.pop();
    double b = val.pop();
    val.push(b / a);
    continue;
    default:
    break;
    }
    }
    op.push(arr[i]);
    }
    else
    val.push(Double.parseDouble(arr[i]));
    }
    while (!op.isEmpty()) {
    switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    break;
    case "-":
    double c = val.pop();
    double d = val.pop();
    val.push(d - c);
    break;
    case "*":
    val.push(val.pop() * val.pop());
    break;
    case "/":
    double a = val.pop();
    double b = val.pop();
    val.push(b / a);
    break;
    default:
    break;
    }
    }
    return val.pop();
    }

    运算实例:

  • public static void main(String[] args) {
    double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
    System.out.println(a);
    System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
    }
    //output:
    -9.2
    -9.2

    至此,完成了四则运算字符串解释器,还有很多可以完善, 比如异常的处理,以及代码的简洁性,作为一个初学者,如果能被看到的话,希望多提建议:

    完整版代码如下:

  • import java.util.ArrayList;
    import java.util.Stack; public class Main { public static void main(String[] args) {
    double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
    System.out.println(a);
    System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
    } //对运算符优先级进一步排序 减法大于加法 除法大于乘法
    public static double caculate2(String formula) {
    String[] arr = convert(formula);
    Stack<Double> val = new Stack<>();
    Stack<String> op = new Stack<>(); for (int i = 0; i < arr.length; i++) {
    if (arr[i].equals("(")) {
    val.push(caculate2(bracketGet(formula, i)));
    i = i + bracketGet(formula, i).length() + 1;
    } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
    switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    continue;
    case "-":
    double c = val.pop();
    double d = val.pop();
    val.push(d - c);
    continue;
    case "*":
    val.push(val.pop() * val.pop());
    continue;
    case "/":
    double a = val.pop();
    double b = val.pop();
    val.push(b / a);
    continue;
    default:
    break;
    }
    }
    op.push(arr[i]);
    }
    else
    val.push(Double.parseDouble(arr[i]));
    }
    while (!op.isEmpty()) {
    switch (op.pop()) {
    case "+":
    val.push(val.pop() + val.pop());
    break;
    case "-":
    double c = val.pop();
    double d = val.pop();
    val.push(d - c);
    break;
    case "*":
    val.push(val.pop() * val.pop());
    break;
    case "/":
    double a = val.pop();
    double b = val.pop();
    val.push(b / a);
    break;
    default:
    break;
    }
    }
    return val.pop();
    } public static String bracketGet(String s, int k) {
    int m=0;
    int i;
    String[] arr=convert(s);
    for(i=k;i<arr.length;i++){
    if(arr[i].equals("(")){
    m++;
    continue;
    }
    if(arr[i].equals(")")){
    m--;
    if(m==0)
    break;
    else
    continue;
    }
    }
    StringBuilder sb=new StringBuilder();
    for(int j=k+1;j<i;j++){
    sb.append(arr[j]);
    }
    return sb.toString();
    } public static String[] convert(String s) {
    ArrayList<String> arrayList = new ArrayList<>();
    for (int i = 0; i < s.length(); i++) {
    if (!opjudge(s.charAt(i))) {
    int j = i;
    while ((i < s.length()) && !opjudge(s.charAt(i)))
    i++;
    arrayList.add(s.substring(j, i));
    i--;
    } else
    arrayList.add(String.valueOf(s.charAt(i)));
    }
    return arrayList.toArray(new String[arrayList.size()]);
    } public static boolean opjudge(char c) {
    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
    return true;
    else
    return false;
    } public static int opvalue2(String s) {
    switch (s) {
    case "+":
    return 1;
    case "-":
    return 2;
    case "*":
    return 3;
    case "/":
    return 4;
    default:
    return -1;
    }
    } public static boolean opcompare2(String s1, String s2) {
    if (opvalue2(s1) >= opvalue2(s2))
    return true;
    else {
    return false;
    }
    }

最近学习到后缀表达式,于是基于后缀表达式的思想,写了一个四则运算解释器,输入字符串类型的四则运算表达式,可以直接得到结果,支持括号嵌套. 
实现时主要考虑以下两点:

  • 字符串中运算符和数字分离
  • 运算符优先级
  • 括号的嵌套

  1. 运算符和数字分离:可以考虑用字符串数组存储
  2. 关于运算符优先级,最开始的想法是将乘除法看作一类,加减法看作一类,乘除法的优先级大于加减法,相同类型的运算符按照从左到右顺序依次计算.
  3. 括号的嵌套:由于括号内部本身也是表达式,因此可以使用递归处理,但重点在于括号的配对,由于使用递归,所以希望获取最大的嵌套单元.

具体实现:

首先实现运算符识别的代码,判断一个字符是否为运算符:

public static boolean opjudge(char c) {
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
return true;
else
return false;
}

然后实现字符串表达式转为字符串数组, 由于要求输入的字符串运算符和数字之间没有空格,所以直接拆分不方便,而且运算符和数字的数目不确定,因此先使用ArrayList存储,然后再转成字符串数组,主要方法是遍历字符串中每一个字符并判断是否为运算符,如果是运算符,则直接将运算符转为字符串加入ArrayList,如果不是,则从此位置继续查找到下一个运算符出现的位置,两个位置之间即为操作数,使用substring截取字符串存入Arraylist,具体实现如下:

    public static String[] convert(String s) {
ArrayList<String> arrayList = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
if (!opjudge(s.charAt(i))) {
int j = i;
while ((i < s.length()) && !opjudge(s.charAt(i)))
i++;
arrayList.add(s.substring(j, i));
i--;
} else
arrayList.add(String.valueOf(s.charAt(i)));
} return arrayList.toArray(new String[arrayList.size()]); :
    public static void main(String[] args) {
double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
System.out.println(a);
System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
}
//output:
-9.2
-9 }

//对运算符优先级进一步排序 减法大于加法 除法大于乘法
public static double caculate2(String formula) {
String[] arr = convert(formula);
Stack<Double> val = new Stack<>();
Stack<String> op = new Stack<>(); for (int i = 0; i < arr.length; i++) {
if (arr[i].equals("(")) {
val.push(caculate2(bracketGet(formula, i)));
i = i + bracketGet(formula, i).length() + 1;
} else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
switch (op.pop()) {
case "+":
val.push(val.pop() + val.pop());
continue;
case "-":
double c = val.pop();
double d = val.pop();
val.push(d - c);
continue;
case "*":
val.push(val.pop() * val.pop());
continue;
case "/":
double a = val.pop();
double b = val.pop();
val.push(b / a);
continue;
default:
break;
}
}
op.push(arr[i]);
}
else
val.push(Double.parseDouble(arr[i])); }
while (!op.isEmpty()) {
switch (op.pop()) {
case "+":
val.push(val.pop() + val.pop());
break;
case "-":
double c = val.pop();
double d = val.pop();
val.push(d - c);
break;
case "*":
val.push(val.pop() * val.pop());
break;
case "/":
double a = val.pop();
double b = val.pop();
val.push(b / a);
break;
default:
break;
}
} return val.pop();
} public static String bracketGet(String s, int k) {
int m=0;
int i;
String[] arr=convert(s);
for(i=k;i<arr.length;i++){
if(arr[i].equals("(")){
m++;
continue;
}
if(arr[i].equals(")")){
m--;
if(m==0)
break;
else
continue;
} }
StringBuilder sb=new StringBuilder();
for(int j=k+1;j<i;j++){
sb.append(arr[j]);
}
return sb.toString();
} public static String[] convert(String s) {
ArrayList<String> arrayList = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
if (!opjudge(s.charAt(i))) {
int j = i;
while ((i < s.length()) && !opjudge(s.charAt(i)))
i++;
arrayList.add(s.substring(j, i));
i--;
} else
arrayList.add(String.valueOf(s.charAt(i)));
} return arrayList.toArray(new String[arrayList.size()]); } public static boolean opjudge(char c) {
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
return true;
else
return false;
} public static int opvalue2(String s) {
switch (s) {
case "+":
return 1;
case "-":
return 2;
case "*":
return 3;
case "/":
return 4;
default:
return -1;
} } public static boolean opcompare2(String s1, String s2) {
if (opvalue2(s1) >= opvalue2(s2))
return true;
else {
return false;
}

JAVA四则运算字符串解释器的更多相关文章

  1. Java常量字符串String理解

    Java常量字符串String理解 以前关于String的理解仅限于三点:1.String 是final类,不可继承2.String 类比较字符串相等时时不能用“ == ”,只能用  "eq ...

  2. Java String字符串/==和equals区别,str。toCharAt(),getBytes,indexOf过滤存在字符,trim()/String与StringBuffer多线程安全/StringBuilder单线程—— 14.0

    课程概要 String 字符串 String字符串常用方法 StringBuffer StringBuilder String字符串: 1.实例化String对象 直接赋值  String str=& ...

  3. java截取字符串中的数字

    java从字符串中提取数字 随便给你一个含有数字的字符串,比如: String s="eert343dfg56756dtry66fggg89dfgf"; 那我们如何把其中的数字提取 ...

  4. 三张图彻底了解Java中字符串的不变性

    转载: 三张图彻底了解Java中字符串的不变性 定义一个字符串 String s = "abcd"; s中保存了string对象的引用.下面的箭头可以理解为"存储他的引用 ...

  5. java中字符串的非空判断

    问题如下:在java 中 字符串为null 如何判断String str;if(str==null) ??str.equal("null") ?? 答:我觉得应该搞清楚字符串对象和 ...

  6. java中字符串String 转 int(转)

    java中字符串String 转 int String -> int s="12345"; int i; 第一种方法:i=Integer.parseInt(s); 第二种方法 ...

  7. Java:字符串类String的功能介绍

    在java中,字符串是一个比较常用的类,因为代码中基本上处理的很多数据都是字符串类型的,因此,掌握字符串类的具体用法显得很重要了. 它的主要功能有如下几种:获取.判断.转换.替换.切割.字串的获取.大 ...

  8. Java空字符串与null的区别和判断字符串是否为空的方法

    Java空字符串与null的区别: 1.类型null表示的是一个对象的值,而并不是一个字符串.例如声明一个对象的引用,String a = null ;""表示的是一个空字符串,也 ...

  9. android112 jni 把java的字符串转换成c的字符串,数组处理

    package com.itheima.charencode; import android.os.Bundle; import android.app.Activity; import androi ...

随机推荐

  1. Android各国语言对照表(values-xxx)

    eg: 阿拉伯 Arabic  SA values-ar Android各国语言对照表https://blog.csdn.net/jiangguohu1/article/details/5044014 ...

  2. PostgreSQL主要优势

    PostgreSQL主要优势:  1. PostgreSQL完全免费,而且是BSD协议,如果你把PostgreSQL改一改,然后再拿去卖钱,也没有人管你,这一点很重要,这表明了PostgreSQL数据 ...

  3. linux下安装openoffice

    一.环境 centos6.9 安装jdk1.6及以上 二.安装依赖 yum install libXext.x86_64 -y yum install freetype -y yum groupins ...

  4. 利用sed把一行的文本文件改成每句一行

    事实证明,至少在mac-osx上,利用sed插入一个换行符是很难的,常规的命令如: sed 's/[\.\?\!]/\n' file 是不可能的,会把那些标点符号变成n. 尝试了SO上的很多方法 ht ...

  5. Python 计数器

    一.counter 1.counter是对字典类型的补充,用于追踪值的出现次数. import collections obj = collections.Counter('aabbccddee') ...

  6. 【Java】 剑指offer(33) 二叉搜索树的后序遍历序列

    本文参考自<剑指offer>一书,代码采用Java语言. 更多:<剑指Offer>Java实现合集   题目 输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果.如 ...

  7. 定制库到maven库

    有一些jar不支持maven,这个时候就可以使用下面的处理方式. kaptcha,它是一个流行的第三方Java库,它被用来生成 “验证码” 的图片,以阻止垃圾邮件,但它不在 Maven 的中央仓库中. ...

  8. mongoDB的配置以及运行

    干嘛的:数据库,nosql(非关系型)   场景:解决大规模数据集合多重数据种类 一.mongoDb安装: 下载地址: https://www.mongodb.com/download-center ...

  9. Java中递归和循环的优劣

    介绍: 你用你手中的钥匙打开一扇门,结果去发现前方还有一扇门,紧接着你又用钥匙打开了这扇门,然后你又看到一扇门......但是当你开到一扇门时,发现前方是一堵墙无路可走了,你选择原路返回--这就是递归 ...

  10. BeagleBone Black的内核移植-从零开始制作镜像

    很多年前做的针对BeagleBone Black开发板的镜像制作,因为当时涉及到非标准化的,所以把基本的kernel.uboot和跟文件系统rootfs都做了一遍,文中只做移植,不作定制化的修改. 如 ...