字符串的四则运算-小江江

字符串的四则运算

作者：小江江

实现思路

首先构思实现需要用到的方法记录下来，之后进行具体的实现（先想后写）。

我的思路：
1.编写需要用到的帮助方法，判断是否为数字、运算符、括号、格式，等等。
2.将运算符在字符串的位置存入TreeMap（有序的）中，key存放索引位置、value存放运算符。
3.将TreeMap中的键存入List中（需要用到List中的get(i)方法），然后根据运算符的索引获取运算符前后的数字进行运算（需要考虑优先级），将运算完的项移除，循环运算直到字符串中不存在运算符，最后返回结果。

代码实现

package com.xiao.sf;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
不求无功，但求无过，谢谢。
 * 四则运算，使用循环+字符串截取+ascll码实现
 */
public class SZUtil {
    /**
     * 测试ascll码
     */
    public void sh(){
        char aa='+',bb='-',x='*',y='/',u='(',t=')';

        int cc=aa,dd=bb,f=x,z=y,n=u,v=t;
        System.out.println((char) 45);
        System.out.println("+:"+cc+"  -:"+dd+"*:"+f+"  /:"+z+" (:"+n+" ):"+y);
    }

    /**
     * 编写一个方法用来判断是否是四则运算符(四则运算符:加减乘除)
     * @param c
     * @return
     */
    public boolean isSz(char c){
        int ascll=c;
        if (ascll==43 || ascll==45 || ascll==42 || ascll==47){
            return true;
        }
        return false;
    }

    /**
     * 判断是否是正负整数
     * @param c
     * @return
     */
    public boolean isNum(char c){
        if (((int)c>47 && (int)c<58) || (int)c==45){
            return true;
        }
        return false;
    }

    /**
     * 判断是否是括号 （  ）
     * @param c
     * @return
     */
    public boolean isKh(char c){
        if (c=='(' || c==')'){
            return true;
        }
        return false;
    }

    /**
     * 判断是否是数字或者运算符和小括号
     * @param str
     * @return
     */
    public boolean pdAll(String str){
        //定义一个字符串用了返回结果
        boolean result=true;

        char[] bytes = str.toCharArray();
        //判断是否只包含运算符和数字
        for (int i=0;i<str.length();i++){
            char u=bytes[i];
            if (isKh(u) || isNum(u) || isSz(u)){
            }else {
                result=false;
                break;
            }
        }

        return result;
    }

    /**
     * 运算规则判断,(并且判断了数字或者运算符和小括号)
     * @param str
     * @return
     */
    public boolean ysgz(String str){
        //判断是否符合运算规则
        if(pdAll(str)){
            //判断前后括号的位置 比如：)1*2 或者 1*3(
            if (str.charAt(0)!=')' && str.charAt(str.length()-1)!='('){
                for (int i=0;i<str.length();i++){
                    //获取运算符的位置
                    if (isSz(str.charAt(i))){
                        //判断运算符是否在第一个位置
                        if (i>0 && i<str.length()-1){
                            //判断运算符前是否是数字或者括号
                            char aa=str.charAt(i-1);
                            if (isNum(aa) || isKh(aa)){
                                //判断运算符后是否是数字或者括号
                                char bb=str.charAt(i+1);
                                if((isNum(bb) && (int)bb!=45) || isKh(bb)){
                                }else {
                                    return false;
                                }
                            }else {
                                return false;
                            }
                        }else {
                            System.err.println("首尾不能存在运算符");
                            return false;
                        }
                    }
                }
            }else {
                System.err.println("首尾括号异常");
                return false;
            }
        }else {
            return false;
        }
        return true;
    }

    /**
     * 括号格式为完整的括号格式
     * @param str
     * @return
     */
    public boolean khgs(String str){
        //判断是否存在括号
        boolean flag=false;
        for (char c:str.toCharArray()) {
            if(isKh(c)){
                flag=true;
              break;
            }
        }
        if (flag){
            Map<Integer,Character> map=new TreeMap<>();
            //获取所有括号
            for (int i=0;i<str.length();i++){
                //得到括号的位置
                if (isKh(str.charAt(i))){
                    map.put(i,str.charAt(i));
                }
            }
            //判断括号是否存在残缺的
            if (map.size()%2==0){
                List<Integer> list=new ArrayList(map.keySet());
                //判断首尾括号的朝向 比如  )(
                if (map.get(list.get(0))=='(' && map.get(list.get(list.size()-1))==')'){
                    //判断左右括号是否对称
                    int left=0;
                    int right=0;
                    for (Integer key:list) {
                        if (map.get(key)=='('){
                            left+=1;
                        }else if (map.get(key)==')'){
                            right+=1;
                        }else {
                            System.err.println("错误");
                        }
                    }
                    if (left==right){

                    }else {
                        System.err.println("左右括号的数量不同");
                        return false;
                    }
                }else {
                    System.err.println("首尾括号的朝向不对");
                    return false;
                }
            }else {
                System.err.println("括号数量不对");
                return false;
            }
        }
        return true;
    }

    /**
     * 帮助计算的方法
     * @param num1  第一个数
     * @param num2  第二个数
     * @param ysf   运算符
     * @return
     */
    public int sumOO(String num1,String num2,String ysf){
        int sum=0;
        switch (ysf){
            case "*":
                sum=Integer.parseInt(num1)*Integer.parseInt(num2);
                break;
            case "/":
                sum=Integer.parseInt(num1)/Integer.parseInt(num2);
                break;
            case "+":
                sum=Integer.parseInt(num1)+Integer.parseInt(num2);
                break;
            case "-":
                sum=Integer.parseInt(num1)-Integer.parseInt(num2);
                break;
            default:
                System.err.println("程序异常");
                break;
        }
        return sum;
    }

    /**
     * 计算（不带括号的正整数）
     * @param str
     * @return
     */
    public String sum1(String str){
        //判断格式
        if (ysgz(str)){
            //不断重复计算，直到结果出来为止
            while (true){
                //拿到运算符的位置，存入TreeMap中
                Map<Integer,Character> map=new TreeMap<>();
                for(int i=0;i<str.length();i++){
                    if (isSz(str.charAt(i))){
                        map.put(i,str.charAt(i));
                    }
                }
                //运算符的位置
                List<Integer> list=new ArrayList<>(map.keySet());
                //乘除的标志  0 代表没有乘除运算符  ||  1 代表存在乘除运算符
                int ccCont=-1;
                //遍历运算符出现的位置，进行运算操作
                for (int i=0;i<list.size();i++) {
                    //根据运算法则 先算乘除 后算加减  "1+3-4*5/5"
                    if (map.get(list.get(i))=='*' || map.get(list.get(i))=='/'){
                        ccCont=1;
                        //当运算符是第一个或最后一个的时候，截取的方式也有所不同
                        if (i==0 || i==(list.size()-1)){
                            //当乘除运算符在第一个位置时  例如： "2*3+3/3"
                            if (i==0){
                                //截取数据
                                String substring = str.substring(0, list.get(i));
                                String substring1 = str.substring(list.get(i)+1,list.get(i+1));
                                int i1 = sumOO(substring, substring1, map.get(list.get(i)) + "");
                                str=i1+""+str.substring(list.get(i+1));
                                break;
                                //return i1+"";
                            //出现在最后一个位置时
                            }else {
                                //截取数据
                                String substring = str.substring(list.get(i-1)+1, list.get(i));
                                String substring1 = str.substring(list.get(i)+1);
                                int i1 = sumOO(substring, substring1, map.get(list.get(i)) + "");
                                str=str.substring(0,list.get(i-1)+1)+""+i1;
                                break;
                            }
                        }else {
                            //截取指定位置的数据
                            String substring = str.substring(list.get(i-1)+1, list.get(i));
                            String substring1 = str.substring(list.get(i)+1, list.get(i+1));
                            //运算
                            int i1 = sumOO(substring, substring1, map.get(list.get(i)) + "");
                            //将计算完的项移除，重新拼接str
                            str=str.substring(0,list.get(i-1)+1)+""+i1+""+str.substring(list.get(i+1));
                            break;
                        }

                    }else {
                        ccCont=0;
                    }
                }
                if (ccCont==0){
                    //通过第一个运算符的位置，拿到第一个数
                    String sds = str.substring(0, list.get(0));
                    for (int i=0;i<list.size();i++){
                        String substring;
                        if (i<list.size()-1){
                           substring= str.substring(list.get(i)+1, list.get(i+1));
                        }else {
                           substring= str.substring(list.get(i) + 1);
                        }
                        int i1 = sumOO(sds, substring, map.get(list.get(i)) + "");
                        sds=i1+"";
                    }
                    return sds;
                }
               // break;
            }
        }
        return "格式不对";
    }
    /**
     * 计算（带括号的正整数）
     * @param str
     * @return
     */
    public String sum2(String str){
        //判断格式
        if (ysgz(str)){
            //判断括号
            if (khgs(str)){
                //反复查找运算符，直到没有运算符为止
                while (true){
                    //判断括号的位置
                    //拿到运算符的位置，存入TreeMap中
                    Map<Integer,Character> map=new TreeMap<>();
                    //将括号的位置存入map中  key 存放索引，value:存放括号  例如：{0=(,5=)}
                    for(int i=0;i<str.length();i++){
                        if (isKh(str.charAt(i))){
                            map.put(i,str.charAt(i));
                        }
                    }
                    //运算符的位置
                    List<Integer> list=new ArrayList<>(map.keySet());
                    for(int i=0;i<list.size();i++){
                        //判断是否只存在最外面的一对括号
                        if (list.size()==2){
                            int index=0;
                            //拿到运算符所在的位置
                            for (int aa=0;aa<str.length();aa++){
                                if (isSz(str.charAt(aa))){
                                    index=aa;
                                    break;
                                }
                            }
                            //组装数据
                            String num1=str.substring(1,index);
                            String num2=str.substring(index+1,str.length()-1);
                            String yuns=str.substring(index,index+1);
                            //调用没有括号的求值方法
                            String s = sum1(str.substring(1, str.length() - 1));
                            /*System.out.println(str);
                            System.out.println(num2);
                            System.out.println(yuns);*/

                            //返回结果
                            return s/*sumOO(num1,num2,yuns)+""*/;
                        }else{
                            //根据运算规则有括号先算括号里面的
                            if (map.get(list.get(i))==')'){
                                //截取
                                String substring = str.substring(list.get(i - 1), list.get(i) + 1);
                                //调用没有括号的进行运算
                                String s = sum1(substring.substring(1, substring.length() - 1));
                                //没作用 str=str.replaceAll(substring,s);
                                //重新拼接str,继续运算
                                str=str.substring(0,list.get(i-1))+s+str.substring(list.get(i)+1);
                                break;
                            }
                        }
                    }
                }
            }
        }
        return "格式错误";
    }
    //测试
    @Test
    public void t1(){
        String str="1*2+30-4*5/5*5";
        System.out.println(sum1(str));
        String str1="(1+(1+1)*(60+3+1*2)+33)";
        System.out.println(sum2(str1));
    }
}