文档章节

四则运算的验证

旋风yu
 旋风yu
发布于 2017/08/18 09:57
字数 1050
阅读 25
收藏 0

package com.cp.dts.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Operate {

    
    public static final String ERROR="表达式太复杂";
    public static final String ERROR1="表达式不正确";
    public static final String ERROR2="表达式缺少左括号或右括号";
    public static final String ERROR3="缺少数字或运算符";
    public static final String ERROR4="浮点数不能以小数点开头";
    
    //判断加减乘除的优先级
    private static Map<String, Integer> priority = new HashMap<>();
    static {  
        priority.put("*", 2);  
        priority.put("/", 2);  
        priority.put("+", 1);  
        priority.put("-", 1);  
        priority.put("", 0); 
        priority.put("(", 3); 
        priority.put(")", 3); 
    } 
    
    //将中文的括号替换为英文的括号
    private static Map<String, String> replace = new HashMap<>();
    static {  
        replace.put("(", "(");  
        replace.put(")", ")");  
    } 
    
    //表示字符串是由数字,字母,下划线,小数点组成的
    private static Pattern pattern = Pattern.compile("^[\\w]?(\\.{0,1}[\\w]+)+$");
    //private static Pattern pattern = Pattern.compile("^\\w+$");
    
    private static Stack<String> stack = new Stack<>(); 
    
    //储存运算符的字符串数组
    private static String[] operator = {"+", "-", "*", "/"};
    
    //判断一个字符是否是数字,字母,下划线,小数点组成
    private static boolean isNumOrAlph(char c) {
        if (Character.isLetter(c)||Character.isDigit(c)||'_'==c||'.'==c) {
            return true;
        }
        return false;
    }
    
    //如果字符串是由数字和字母和下划线组成的则返回true
    private static boolean isNumOrAlph(String str) {
        Matcher matcher = pattern.matcher(str);
        if (matcher.matches()) {
            return true;
        }
        return false;
    }
    
    //返回的是由数字和字母和下划线组成的字符串或者是运算符
    private static String popNextElement(StringBuilder expression) {  
        StringBuilder result = new StringBuilder();  
        char c = expression.charAt(0); 
        expression.deleteCharAt(0);  
        result.append(c);  
          
        if (isNumOrAlph(c)) {  
            while ( expression.length() >0 && isNumOrAlph(c = expression.charAt(0))) {  
                expression.deleteCharAt(0);  
                result.append(c);  
            } 
        }  
  
        return result.toString();  
    }
    
    //判断此字符串是否是运算符
    private static boolean isOperator(String str) {
        for (int i = 0; i < operator.length; i++) {
            if (operator[i].equals(str)) {
                return true;
            }
        }
        return false;
    }
    
    //获得栈顶运算符
    private static String getTopOperator() {
        if (stack.size()>0) {
            return stack.get(stack.size() - 1);
        }
        return "";
    }
    
    //判断运算符是否符合规则
    public static String verify(String expression){
        HashMap<Object, Integer> hashMap=new HashMap<Object, Integer>();
        StringBuilder inffix = new StringBuilder(expression.trim());
        String element ="";
        List<String> list=new ArrayList<String>();
        Integer value1=1;
        Integer value2=1;
        Integer value3=1;
        Integer value4=1;
        while (inffix.length() > 0){
            element = popNextElement(inffix);
            if (element.charAt(0)=='.') {
                return ERROR4;
            }
            list.add(element);
            if ("(".equals(element)) {
                element=replace.get("(");
            }else if (")".equals(element)) {
                element=replace.get(")");
            }
            if ("(".equals(element)) {
                if (hashMap.get("(")==null) {
                    hashMap.put("(", 1);
                }else {
                    value1++;
                    hashMap.put("(", value1);
                }
            }else if (")".equals(element)) {
                if (hashMap.get(")")==null) {
                    hashMap.put(")", 1);
                }else {
                    value2++;
                    hashMap.put(")", value2);
                }
            }else if (isOperator(element)) {
                if (hashMap.get("operator")==null) {
                    hashMap.put("operator", 1);
                }else {
                    value3++;
                    hashMap.put("operator", value3);
                }
            }else if (isNumOrAlph(element)) {
                if (hashMap.get("numOrAlph")==null) {
                    hashMap.put("numOrAlph", 1);
                }else {
                    value4++;
                    hashMap.put("numOrAlph", value4);
                }
            }else{
                return ERROR1;
            }
            
        }
        if (hashMap.get("(")!=hashMap.get(")")) {
            return ERROR2;
        }
        if (hashMap.get("numOrAlph")-hashMap.get("operator")!=1) {
            System.out.println(hashMap.get("numOrAlph"));
            System.out.println(hashMap.get("operator"));
            return ERROR3;
        }
        System.out.println(list.size()+"66666666");
        
        int flag=0;
        //判断左括号前必须是运算符或空,左括号后必须是数字,右括号同理。
        for (int i = 0; i < list.size(); i++) {
            if ("(".equals(list.get(i))) {
                flag++;
                if (i!=0) {
                    if (!isOperator(list.get(i-1))&&!"(".equals(list.get(i-1))) {
                        return ERROR1;
                    }
                    if (!isNumOrAlph(list.get(i+1))&&!"(".equals(list.get(i+1))) {
                        return ERROR1;
                    }
                }else{
                    if (!isNumOrAlph(list.get(i+1))&&!"(".equals(list.get(i+1))) {
                        return ERROR1;
                    }
                }
            }
            if (")".equals(list.get(i))) {
                flag--;
                if (i!=list.size()-1) {
                    if (!isOperator(list.get(i+1))&&!")".equals(list.get(i+1))) {
                        return ERROR1;
                    }
                    if (!isNumOrAlph(list.get(i-1))&&!")".equals(list.get(i-1))) {
                        return ERROR1;
                    }
                }else{
                    if (!isNumOrAlph(list.get(i-1))&&!")".equals(list.get(i-1))) {
                        return ERROR1;
                    }
                }
            }
            if (flag>=3) {
                return ERROR;
            }
        }
        return null;
    }
    
    // 将中缀表达式转化为后缀表达式
    public static String inffixToSuffix(String expression) {
        String str=verify(expression.trim());
        if (str==ERROR1) {
            return ERROR1;
        }else if (str==ERROR2) {
            return ERROR2;
        }else if (str==ERROR3) {
            return ERROR3;
        }else if (str==ERROR) {
            return ERROR;
        }else if (str==ERROR4) {
            return ERROR4;
        }
        stack.clear();
        StringBuilder inffix = new StringBuilder(expression.trim());// 中缀表达式
        StringBuilder suffix = new StringBuilder();// 后缀表达式
        String element = "";
        String tmp = "";

        while (inffix.length() > 0) {
            element = popNextElement(inffix);
            //将中文的括号替换为英文的括号
            if ("(".equals(element)) {
                element=replace.get("(");
            }else if (")".equals(element)) {
                element=replace.get(")");
            }
            // 如果element是由数字,字母,下划线组成的字符串就添加到后缀表达式中
            if (isNumOrAlph(element)) {
                suffix.append(element).append(",");
            /*
             * 如果优先级大于或等于栈顶优先级且不为")"时,分两种情况,一种直接压栈,另一种就是优先级相
             * 等且不"("时,是先让栈顶的运算符出栈,再压栈
             */        
            } else if (!")".equals(element)&& priority.get(element) >= priority.get(getTopOperator())) {
                
                if (!"(".equals(element)&& priority.get(element) == priority.get(getTopOperator())) {
                    tmp = stack.pop();
                    suffix.append(tmp).append(",");
                }
                stack.push(element);
                /*
                 * 如果优先级小于栈顶优先级且不为")"时,分两种情况,一种是"("不在栈顶,先让栈顶的运算符
                 * 出栈,再压栈,另一种就是"("在栈顶,就直接压栈
                 */
            } else if (!")".equals(element)&& priority.get(element) < priority.get(getTopOperator())) {
                if (!"(".equals(getTopOperator())) {
                    tmp = stack.pop();
                    suffix.append(tmp).append(",");
                    stack.push(element);
                }else {
                    stack.push(element);
                }
                /*
                 * 当元素为")"时,把栈顶符号都弹出,直到出现"("为止
                 * 
                 */
            } else if (")".equals(element)) {
                tmp = stack.pop();
                while (!"(".equals(tmp)) {
                    suffix.append(tmp).append(",");
                    tmp = stack.pop();
                }
            }
            
        }
        //把剩余的栈中的符合都弹出
        while (stack.size() > 0) {
            suffix.append(stack.pop()).append(",");
        }
        return suffix.toString();

    }

    public static void main(String[] args) {
        System.out.println(isNumOrAlph(".0"));
        System.out.println(inffixToSuffix("((ABD_EC132+ABD_EC146)*2.5+6)/2+ABD_EC130"));
    }
}
 

© 著作权归作者所有

旋风yu
粉丝 0
博文 3
码字总数 1750
作品 0
德阳
私信 提问
学以致用——Java源码——小学中低年级四则运算练习及考试程序(Computer-Assisted Instruction)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/hpdlzu80100/article/details/85234868 这个程序用来给小孩做数学练习应该还是不错的! 程序主要功能: 1. 可...

预见未来to50
2018/12/24
0
0
Qt之加减乘除四则运算-支持负数

一、效果展示 如图1所示,是简单的四则运算测试效果,第一列为原始表达式,第二列为转换后的后缀表达式,冒号后为结果。表达式支持负数和空格,图中是使用了5组测试数据,测试结果可能不全,...

朝十晚八
2018/07/23
0
0
Flex:Web报表引擎——MyReport 2.3.0.0新功能

新增功能 表达式引擎 重新设计的表达式引擎,支持16种运算符,能够进行四则运算、逻辑运算;支持40多个常用函数,能够进行复杂的数据统计,数据运算,流程处理;支持四则运算、逻辑运算嵌套函...

彭博
2012/03/09
61
0
shell脚本中的双括号用法

在刚开始学习inux shell脚本编程时候,对于它的 四则运算以及逻辑运算。估计很多朋友都感觉比较难以接受。特变逻辑运算符”[]”使用时候,必须保证运算符与算数 之间有空格。 四则运算也只能...

zhangyujsj
2016/06/27
100
0
Python3内置容器之例子

1.归并排序 2.按单词反转字符串 3.找出列表不重复元素并按原来的顺序 4.查找一个列表中的最大值 PS: partition ==> rpartition 6.不适用组合数打印杨辉三角...

夏洛特_
2016/09/13
16
0

没有更多内容

加载失败,请刷新页面

加载更多

面试题必备-web页面基础

html标签是由<>包围的关键词 html标签是成对出现的 有部分标签是没有结束标签的,叫单标签, 页面中所有的内容,都是要放在HTML标签中的 HTML标签分三部分: 标签名称 标签内容 标签属性 HT...

达达前端小酒馆
今天
11
0
OSChina 周二乱弹 —— 女装大佬被拆穿是妹子假扮

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 小小编辑推荐:《All of the Stars》- Ed Sheeran 《All of the Stars》- Ed Sheeran 手机党少年们想听歌,请使劲儿戳(这里) @Leon_swool ...

小小编辑
今天
802
9
3. 彤哥说netty系列之Java BIO NIO AIO进化史

你好,我是彤哥,本篇是netty系列的第三篇。 欢迎来我的公从号彤哥读源码系统地学习源码&架构的知识。 简介 上一章我们介绍了IO的五种模型,实际上Java只支持其中的三种,即BIO/NIO/AIO。 本...

彤哥读源码
今天
51
0
02.日志系统:一条SQL更新语句是如何执行的?

我们还是从一个表的一条更新语句说起,我们创建下面一张表: create table T(ID int primary key, c int); 如果要将ID=2这一行c的值加1,SQL可以这么写: update T set c=c+1 where ID=2; 前...

scgaopan
今天
12
0
【五分钟系列】掌握vscode调试技巧

调试前端js 准备一个前端项目 index.html <!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1......

aoping
今天
12
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部