精华内容
下载资源
问答
  • java计算数学表达式

    2013-05-07 12:55:07
    java计算数学表达式,加减乘除,用正则表达式
  • java代码实现中缀表达式转后缀表达式,并计算结果
  • Java字符串转换成算术表达式计算并输出结果,通过这个工具可以直接对字符串形式的算术表达式进行运算,并且使用非常简单。 这个工具中包含两个 Calculator 和 ArithHelper Calculator 代码如下: import java....

    原文地址:   https://www.cnblogs.com/woider/p/5331391.html

    Java字符串转换成算术表达式计算并输出结果,通过这个工具可以直接对字符串形式的算术表达式进行运算,并且使用非常简单。

    这个工具中包含两个类 Calculator 和 ArithHelper

    Calculator 代码如下:

    import java.util.Collections;
    import java.util.Stack;
    
    /**
     *  算数表达式求值 
     *  直接调用Calculator的类方法conversion() 
     *  传入算数表达式,将返回一个浮点值结果
     *  如果计算过程错误,将返回一个NaN
     */
    public class Calculator {
        private Stack<String> postfixStack = new Stack<String>();// 后缀式栈
        private Stack<Character> opStack = new Stack<Character>();// 运算符栈
        private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };// 运用运算符ASCII码-40做索引的运算符优先级
    
        public static double conversion(String expression) {
            double result = 0;
            Calculator cal = new Calculator();
            try {
                expression = transform(expression);
                result = cal.calculate(expression);
            } catch (Exception e) {
                // e.printStackTrace();
                // 运算错误返回NaN
                return 0.0 / 0.0;
            }
            // return new String().valueOf(result);
            return result;
        }
    
        /**
         * 将表达式中负数的符号更改
         *
         * @param expression
         *            例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
         * @return
         */
        private static String transform(String expression) {
            char[] arr = expression.toCharArray();
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == '-') {
                    if (i == 0) {
                        arr[i] = '~';
                    } else {
                        char c = arr[i - 1];
                        if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
                            arr[i] = '~';
                        }
                    }
                }
            }
            if(arr[0]=='~'||arr[1]=='('){
                arr[0]='-';
                return "0"+new String(arr);
            }else{
                return new String(arr);
            }
        }
    
        /**
         * 按照给定的表达式计算
         *
         * @param expression
         *            要计算的表达式例如:5+12*(3+5)/7
         * @return
         */
        public double calculate(String expression) {
            Stack<String> resultStack = new Stack<String>();
            prepare(expression);
            Collections.reverse(postfixStack);// 将后缀式栈反转
            String firstValue, secondValue, currentValue;// 参与计算的第一个值,第二个值和算术运算符
            while (!postfixStack.isEmpty()) {
                currentValue = postfixStack.pop();
                if (!isOperator(currentValue.charAt(0))) {// 如果不是运算符则存入操作数栈中
                    currentValue = currentValue.replace("~", "-");
                    resultStack.push(currentValue);
                } else {// 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
                    secondValue = resultStack.pop();
                    firstValue = resultStack.pop();
    
                    // 将负数标记符改为负号
                    firstValue = firstValue.replace("~", "-");
                    secondValue = secondValue.replace("~", "-");
    
                    String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
                    resultStack.push(tempResult);
                }
            }
                return Double.valueOf(resultStack.pop());
        }
    
        /**
         * 数据准备阶段将表达式转换成为后缀式栈
         * 
         * @param expression
         */
        private void prepare(String expression) {
            opStack.push(',');// 运算符放入栈底元素逗号,此符号优先级最低
            char[] arr = expression.toCharArray();
            int currentIndex = 0;// 当前字符的位置
            int count = 0;// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
            char currentOp, peekOp;// 当前操作符和栈顶操作符
            for (int i = 0; i < arr.length; i++) {
                currentOp = arr[i];
                if (isOperator(currentOp)) {// 如果当前字符是运算符
                    if (count > 0) {
                        postfixStack.push(new String(arr, currentIndex, count));// 取两个运算符之间的数字
                    }
                    peekOp = opStack.peek();
                    if (currentOp == ')') {// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
                        while (opStack.peek() != '(') {
                            postfixStack.push(String.valueOf(opStack.pop()));
                        }
                        opStack.pop();
                    } else {
                        while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
                            postfixStack.push(String.valueOf(opStack.pop()));
                            peekOp = opStack.peek();
                        }
                        opStack.push(currentOp);
                    }
                    count = 0;
                    currentIndex = i + 1;
                } else {
                    count++;
                }
            }
            if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
                postfixStack.push(new String(arr, currentIndex, count));
            }
    
            while (opStack.peek() != ',') {
                postfixStack.push(String.valueOf(opStack.pop()));// 将操作符栈中的剩余的元素添加到后缀式栈中
            }
        }
    
        /**
         * 判断是否为算术符号
         *
         * @param c
         * @return
         */
        private boolean isOperator(char c) {
            return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
        }
    
        /**
         * 利用ASCII码-40做下标去算术符号优先级
         *
         * @param cur
         * @param peek
         * @return
         */
        public boolean compare(char cur, char peek) {// 如果是peek优先级高于cur,返回true,默认都是peek优先级要低
            boolean result = false;
            if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
                result = true;
            }
            return result;
        }
    
        /**
         * 按照给定的算术运算符做计算
         *
         * @param firstValue
         * @param secondValue
         * @param currentOp
         * @return
         */
        private String calculate(String firstValue, String secondValue, char currentOp) {
            String result = "";
            switch (currentOp) {
            case '+':
                result = String.valueOf(ArithHelper.add(firstValue, secondValue));
                break;
            case '-':
                result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
                break;
            case '*':
                result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
                break;
            case '/':
                result = String.valueOf(ArithHelper.div(firstValue, secondValue));
                break;
            }
            return result;
        }
    }

    ArithHelper 代码如下:

    public class ArithHelper {
    
        // 默认除法运算精度
        private static final int DEF_DIV_SCALE = 16;
    
        // 这个类不能实例化
        private ArithHelper() {
        }
    
        /**
         * 提供精确的加法运算。
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和
         */
    
        public static double add(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }
    
        public static double add(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.add(b2).doubleValue();
        }
    
        /**
         * 提供精确的减法运算。
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差
         */
    
        public static double sub(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }
    
        public static double sub(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.subtract(b2).doubleValue();
        }
    
        /**
         * 提供精确的乘法运算。
         *
         * @param v1
         *            被乘数
         * @param v2
         *            乘数
         * @return 两个参数的积
         */
    
        public static double mul(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }
    
        public static double mul(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.multiply(b2).doubleValue();
        }
    
        /**
         * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后10位,以后的数字四舍五入。
         *
         * @param v1
         *            被除数
         * @param v2
         *            除数
         * @return 两个参数的商
         */
    
        public static double div(double v1, double v2) {
            return div(v1, v2, DEF_DIV_SCALE);
        }
    
        public static double div(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入。
         *
         * @param v1 被除数
         * @param v2 除数
         * @param scale 表示表示需要精确到小数点以后几位。
         * @return 两个参数的商
         */
    
        public static double div(double v1, double v2, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 提供精确的小数位四舍五入处理。
         *
         * @param v 需要四舍五入的数字
         * @param scale 小数点后保留几位
         * @return 四舍五入后的结果
         */
    
        public static double round(double v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
            java.math.BigDecimal one = new java.math.BigDecimal("1");
            return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        public static double round(String v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b = new java.math.BigDecimal(v);
            java.math.BigDecimal one = new java.math.BigDecimal("1");
            return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    }

    使用时调用 Calculator 类的 conversion()方法,并传入算术表达式参数,即可返回一个 Double 类型的值。

    使用示例:

     1 public class MathTest {
     2 
     3      public static void main(String[] args) {
     4      String expression = "(0*1--3)-5/-4-(3*(-2.13))";
     5      double result = Calculator.conversion(expression);
     6      System.out.println(expression + " = " + result);
     7      System.out.println();
     8      }
     9      
    10 }

    控制台输出:

    1

    (0*1--3)-5/-4-(3*(-2.13)) = 10.64

    测试截图:

    展开全文
  • **背景: 使用js引擎的eval 以及另一引擎(记不清名字在了)在进行诸如1+2*3-1.2等计算时, 会出现损失精度的问题... 为了解决该问题, 编写了该工具类。 因为公司规定(懒得再写第二遍了。。), 只能拍照以作记录。**

    背景: 使用js引擎的eval 以及另一引擎(记不清名字在了)在进行诸如1+2*3-1.2等计算时, 会出现损失精度的问题。 为了解决该问题, 编写了该工具类。 因为公司规定(懒得再写第二遍了。。), 只能拍照以作记录。

    代码设计:
    1. 核心: 将运算公式每次均计算前三, 依次循环。
    2.  按照优先级,优先解决公式中的括号中的运算。
    
    代码如下, 建议debug跟踪一下。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 今天小编就为大家分享一篇java实现字符串四则运算公式解析工具类的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 一个不错的java表达式计算工具

    千次阅读 2019-02-15 15:47:49
    在我们的项目中,如果是做流程或者是一些涉及到计算的模块时,是不是有动态进行计算的需求呀。   比如,我们从配置里读取到一个公式,比如最简单的 sin(A) + cos(B) 你会怎样实现呢,   这个实现上没有多大的...

    在我们的项目中,如果是做流程或者是一些涉及到计算的模块时,是不是有动态进行计算的需求呀。

     

    比如,我们从配置里读取到一个公式,比如最简单的 sin(A) + cos(B) 你会怎样实现呢,

     

    这个实现上没有多大的困难,从最简单的hard code的解析,到正则表达解析,或者是AST语法树解析,或者用bsh,jython,jruby/groovy等脚本引擎,或者更有甚者直接用sql执行,等等方法多种多样。不过每种方法或多或少都有自己一定的局限。如何找到一个比较好的解决方案呢。

     

    这里给大家推荐一个比较不错灵活的公式模块的java实现equals

    (除了支持简单的数字及运算符号运算, 最关键的是支持很多有关金融数学领域里的集合的运算)

    equals是exceoon的david.liu在google codes里贡献的一个项目。是实现公式计算模板的一个解决方案。该项目在多个商业的股票行情软件的自编规则和自编指标的模块中得以广泛应用,有使用过股票软件的朋友,应该对选股器和自定义指标这两个功能比较熟悉吧。

     

    也就是客户自己在编辑器一定义出一个或者是一套计算公式,然后程序会根据你指定的公式进行计算,当然作为商业上的应用,这里的计算不仅仅局限于加减乘除,还包含标准偏差,平均线,移动平均线等指标的计算。

     

    比如下面的这段测试代码

     

    String txt = "DIF:EMA(CLOSE,SHORT)-EMA(OPEN,LONG);"
                                + "DEA:EMA(DIF,MID);"

                                + "MACD:(DIF-DEA)*2::COLORSTICK;";

     

    先定义一个公式 这个公式是计算股票的指标MACD的。

     

    String[] defs = new String[]
                           { "SHORT", "LONG", "MID" };

     

    定义公式中的输入参数

     

    Formula f = null;
    f = FormulaBuilder.constructFormula(txt, defs);

    声明一个Formula的变量,这里就是整个公式计算的entry

     

    FormulaParameters fp = new FormulaParameters();
    fp.addParameter("short", 12);
    fp.addParameter("long", 26);
    fp.addParameter("mid", 9);

    声明公式需要的输入变量。

     

    FormulaResult fr = f.eval(fp);
    Map<String, Object> results = fr.getResult();

     

    进行计算得到结果

     

     

    运行最后的结果

     

    {dea=[0.9358484784928137, 5.223248740604646, 9.484484720782131, 12.812405231923686, 17.625797032274512, 21.48934699188941, 24.338687429831023, 24.967767843873517, 23.713504323762475, 23.419514164728735, 22.735086398910138, 22.495512066265064, 22.42045061047972, 21.686444772033873, 20.699838512275377, 19.800386512274844, 20.637560544699593, 22.159859719130218, 24.403776610862046, 24.227408662528966, 22.137340048573154, 21.27741048836811, 20.240579387890197, 19.05695339586254, 16.70384447055847, 16.076128111445378, 14.878188371277464, 13.761807666795649, 13.446553319790361, 14.507684011227127, 13.374907832743064, 10.633227879860222, 8.01815943098602, 5.102424718335767, 2.3071096698386544, -0.3636299728305956, -1.0764588575814014, -2.007847505375248, -3.3771308924710546, -2.992205267376599, -3.409601523132302, -3.152630485981012, -1.652301728989015, 0.06031436069506646, 2.1743828361502264, 3.225697255197028, 5.4291566819545904, 5.2381674589246146, 6.318190562739442, 6.539097031605232, 8.047663761906332, 6.987127060299267, 6.393116866583883, 5.5090016976278795, 5.697663742732732, 4.697814328207814, 2.9086831988864628, 2.2716142389282123, 1.5414277242134833, 0.511061516567303, 0.5807628095128398, 2.356397569537216, 4.278134723604381, 4.052172273526611, 5.2945745230142816, 4.856523216525936, 4.856215977440695, 4.448840846212395, 4.620369162264453, 4.711465166220274, 5.204702439818421, 6.139324792095153, 6.07435288804274, 5.050472337328575, 2.760808950677174, 1.0762871740060749, -0.3525313760925096, -0.4576312199107083, -0.3576855874336494, -0.047701505433911356, -0.45477110003830445, -1.5058191379602623, -3.437010627869526, -4.072244650056223, -2.541007163949839, -2.0103388844296686, -2.50312479232222, -2.2894491447695273, -0.5914388323214326, -0.4169389134949677, -0.012264436855367211, 0.687085671118843, 2.5344611936514294, 4.747483969091154, 5.063547335745879, 6.866522716801898, 6.918328460171757, 7.541830872993569, 8.271715110463383, 10.144861208894433], macd=[7.48678782794251, 34.29920209689466, 34.08988784141987, 26.623364089132433, 38.5071344028066, 30.90839967691918, 22.794723503532886, 5.032643312339985, -10.03410816088833, -2.3519212722699123, -5.4754221265487715, -1.9165946611605875, -0.6004916462827623, -5.872046707566781, -7.892850078067966, -7.1956160000042715, 6.6973922593979935, 12.178393395444985, 17.951335133854613, -1.4109435866646578, -16.720548911646496, -6.879436481640376, -8.2946488038233, -9.469007936221267, -18.82487140243257, -5.021730872904712, -9.583517921343322, -8.931045635854506, -2.522034776042304, 8.489045531494128, -9.062209427872492, -21.93343962306274, -20.92054759099361, -23.325877701202014, -22.362520387976904, -21.365917141354, -5.702631078006446, -7.4511091823507725, -10.95426709676645, 3.079405000755645, -3.3391700460456244, 2.0557682972103173, 12.002630055935978, 13.70092871747265, 16.91254780364128, 8.410515352374414, 17.627675414060498, -1.5279137842398, 8.640184830518628, 1.7672517509263166, 12.06853384240879, -8.484293612856522, -4.752081549723076, -7.0729213516480325, 1.5092963608388121, -7.998795316199338, -14.313049034570806, -5.096551679666001, -5.8414921177178325, -8.242929661169443, 0.5576103435642941, 14.205078080195007, 15.373897232537331, -1.807699600622163, 9.939217995901362, -3.5044104519067645, -0.002457912681927965, -3.259001049826402, 1.372226528416462, 0.7287680316465632, 3.9458981887851756, 7.476978818213864, -0.5197752324193079, -8.19104440571332, -18.317307093211213, -13.476174213368791, -11.430548400788675, -0.8407987505455898, 0.7995650598164714, 2.4798726559979047, -3.2565567568351446, -8.408384303375662, -15.449531919274108, -5.081872177493574, 12.249899888851068, 4.245346236161361, -3.942287263140411, 1.709405180421541, 13.584082499584758, 1.395999350611719, 3.237395813116804, 5.594800863793681, 14.779004180260689, 17.704182203517796, 2.5285069332377965, 14.423803048448146, 0.41444594695887815, 4.988019302574491, 5.839073899758503, 14.985168787448416], dif=[4.679242392464069, 22.372849789051976, 26.529428641492068, 26.124087276489902, 36.87936423367781, 36.943546830349, 35.736049181597465, 27.48408950004351, 18.69645024331831, 22.24355352859378, 19.997375335635752, 21.53721473568477, 22.120204787338338, 18.750421418250482, 16.753413473241395, 16.20257851227271, 23.98625667439859, 28.24905641685271, 33.37944417778935, 23.521936869196637, 13.777065592749906, 17.83769224754792, 16.093254985978547, 14.322449427751906, 7.291408769342183, 13.565262674993022, 10.086429410605803, 9.296284848868396, 12.18553593176921, 18.75220677697419, 8.843803118806818, -0.33349193167114777, -2.442114364510786, -6.56051413226524, -8.874150524149798, -11.046588543507596, -3.927774396584624, -5.733402096550634, -8.85426444085428, -1.4525027669987765, -5.079186546155114, -2.1247463373758535, 4.349013298978974, 6.910778719431391, 10.630656737970867, 7.430954931384235, 14.24299438898484, 4.4742105668047145, 10.638282977998756, 7.42272290706839, 14.081930683110727, 2.744980253871006, 4.017076091722345, 1.9725410218038633, 6.452311923152138, 0.6984166701081449, -4.24784131839894, -0.276661600904788, -1.3793183346454327, -3.610403314017418, 0.8595679812949868, 9.45893660963472, 11.965083339873047, 3.1483224732155293, 10.264183520964963, 3.1043179905725538, 4.854987021099731, 2.819340321299194, 5.306482426472684, 5.075849182043555, 7.177651534211009, 9.877814201202085, 5.814465271833086, 0.9549501344719147, -6.397844595928433, -5.661799932678321, -6.0678055764868475, -0.8780305951835032, 0.042096942474586285, 1.192234822565041, -2.0830494784558766, -5.710011289648094, -11.16177658750658, -6.61318073880301, 3.583942780475695, 0.11233423365101203, -4.4742684238924255, -1.4347465545587568, 6.200602417470947, 0.2810607618108918, 1.6064334697030347, 3.4844861030156835, 9.923963283781774, 13.599575070850051, 6.327800802364777, 14.07842424102597, 7.1255514336511965, 10.035840524280815, 11.191252060342634, 17.63744560261864]}

     

    这个例子是专门针对股票中的一个指标做的公式。最后的计算结果是测试数据的结果,

     

    项目地址: http://code.google.com/p/exceoon/source/browse/trunk#trunk/components/equals

    CSDN源码下载  https://download.csdn.net/download/inthirties/10959047

    展开全文
  • 一个java正规表达式工具类

    千次阅读 2012-04-22 21:06:01
    * 简介: 使用正则表达式验证数据或提取数据,中的方法全为静态的 * 在这里,我将这个定义成了一个单例, * (本来只有static 方法是不new去对象的,也就用不到单例了) * 是因为有一个 ...

     1.匹配图象;                      2 匹配email地址;                    3 匹配匹配并提取url ;                         4 匹配并提取http ;

     5.匹配日期                       6 匹配电话;                            7 匹配身份证                                       8 匹配邮编代码

     9. 不包括特殊字符的匹配 

     (字符串中不包括符号 数学次方号^ 单引号' 双引号" 分号; 逗号, 帽号: 数学减号- 右尖括号> 左尖括号<  反斜杠\ 即空格,制表符,回车符等 

    10 匹配非负整数(正整数 + 0)                                         11 匹配不包括零的非负整数(正整数 > 0)

    12 匹配正整数                                                                  13  匹配非正整数(负整数 + 0)                                                

    14 匹配负整数;                                                                 15. 匹配整数 ;

    16 匹配非负浮点数(正浮点数 + 0)                                17. 匹配正浮点数

    18 匹配非正浮点数(负浮点数 + 0)                                19 匹配负浮点数;                          

     20 .匹配浮点数;                                                                21. 匹配由26个英文字母组成的字符串;   

     22. 匹配由26个英文字母的大写组成的字符串                   23 匹配由26个英文字母的小写组成的字符串 

     24 匹配由数字和26个英文字母组成的字符串;                   25  匹配由数字、26个英文字母或者下划线组成的字符串


    import java.util.*;
    
    import org.apache.oro.text.regex.*;
    import com.juyee.general.helpers.StringHelp;
    
    /**
     * 类简介: 使用正则表达式验证数据或提取数据,类中的方法全为静态的<br/>
     *          在这里,我将这个类定义成了一个单例,
     *         (本来只有static 方法是不new去对象的,也就用不到单例了)<br/>
     *           是因为有一个 regexpHash(HashMap实例),为了可以动态
     *          添加正规表达式(不知道是不是想的太多了:) )。
     *  <pre>
     * 主要方法:1. isHardRegexpValidate(String source, String regexp)
     *             区分大小写敏感的正规表达式批配
     *          2. isSoftRegexpValidate(String source, String regexp)
     *             不区分大小写的正规表达式批配
     *          3. getHardRegexpMatchResult(String source, String regexp)
     *             返回许要的批配结果集(大小写敏感的正规表达式批配)
     *          4. getSoftRegexpMatchResult(String source, String regexp)
     *             返回许要的批配结果集(不区分大小写的正规表达式批配)
     *          5  getHardRegexpArray(String source, String regexp)
     *             返回许要的批配结果集(大小写敏感的正规表达式批配)
     *          6. getSoftRegexpMatchResult(String source, String regexp)
     *             返回许要的批配结果集(不区分大小写的正规表达式批配)
     *          7.  getBetweenSeparatorStr(final String originStr,final char leftSeparator,final char rightSeparator)
     *             得到指定分隔符中间的字符串的集合
     * 正规表达式目前共 25种
     *           1.匹配图象
                    icon_regexp;
    
                 2 匹配email地址
                    email_regexp;
    
                 3 匹配匹配并提取url
                    url_regexp;
    
                 4 匹配并提取http
                    http_regexp;
    
                 5.匹配日期
                    date_regexp;
    
                 6 匹配电话
                    phone_regexp;
     
                 7 匹配身份证
                    ID_card_regexp;
     
                 8 匹配邮编代码
                    ZIP_regexp
    
                 9. 不包括特殊字符的匹配 (字符串中不包括符号 数学次方号^ 单引号' 双引号" 分号; 逗号, 帽号:
                   数学减号- 右尖括号> 左尖括号<  反斜杠\ 即空格,制表符,回车符等
                    non_special_char_regexp;
    
                 10 匹配非负整数(正整数 + 0)
                    non_negative_integers_regexp;
    
                 11  匹配不包括零的非负整数(正整数 > 0)
                    non_zero_negative_integers_regexp;
    
                 12 匹配正整数
                    positive_integer_regexp;
    
                 13  匹配非正整数(负整数 + 0)
                    non_positive_integers_regexp;
     
                 14 匹配负整数
                    negative_integers_regexp;
    
                 15. 匹配整数
                    integer_regexp;
    
                 16 匹配非负浮点数(正浮点数 + 0)
                     non_negative_rational_numbers_regexp
    
                 17. 匹配正浮点数
                     positive_rational_numbers_regexp
    
                 18 匹配非正浮点数(负浮点数 + 0)
                     non_positive_rational_numbers_regexp;
    
                 19 匹配负浮点数
                     negative_rational_numbers_regexp;
    
                 20 .匹配浮点数
                     rational_numbers_regexp;
    
                 21. 匹配由26个英文字母组成的字符串
                     letter_regexp;
    
                 22. 匹配由26个英文字母的大写组成的字符串
                     upward_letter_regexp;
    
                23 匹配由26个英文字母的小写组成的字符串
                     lower_letter_regexp
    
                24 匹配由数字和26个英文字母组成的字符串
                     letter_number_regexp;
    
                25  匹配由数字、26个英文字母或者下划线组成的字符串
                     letter_number_underline_regexp;
     * </pre>
     *
     *
     * @mail wuzhi2000@hotmail.com
     * @author ygj
     *
     */
    public final class Regexp
    {
    
        /**  保放有四组对应分隔符 */
        static final  Set SEPARATOR_SET=new TreeSet();
        {
                   SEPARATOR_SET.add("(");
                   SEPARATOR_SET.add(")");
                   SEPARATOR_SET.add("[");
                   SEPARATOR_SET.add("]");
                   SEPARATOR_SET.add("{");
                   SEPARATOR_SET.add("}");
                   SEPARATOR_SET.add("<");
                   SEPARATOR_SET.add(">");
        }
    
    
    	/** 存放各种正规表达式(以key->value的形式) */
    	public static HashMap regexpHash = new HashMap();
    
    	/** 存放各种正规表达式(以key->value的形式) */
    	public static  List matchingResultList = new ArrayList();
    
        private Regexp()
        {
        }
        /**
         * 返回 Regexp 实例
         * @return
         */
        public static Regexp getInstance()
        {
            return new Regexp();
        }
    
    	/**
    	 * 匹配图象 <br>
    	 *
    	 * 格式: /相对路径/文件名.后缀 (后缀为gif,dmp,png)
    	 *
    	 * 匹配 : /forum/head_icon/admini2005111_ff.gif 或 admini2005111.dmp<br>
    	 *
    	 * 不匹配: c:/admins4512.gif
    	 *
    	 */
    	public static final String icon_regexp = "^(/{0,1}\\w){1,}\\.(gif|dmp|png|jpg)$|^\\w{1,}\\.(gif|dmp|png|jpg)$";
    
    	/**
    	 * 匹配email地址 <br>
    	 *
    	 * 格式: XXX@XXX.XXX.XX
    	 *
    	 * 匹配 : foo@bar.com 或 foobar@foobar.com.au <br>
    	 *
    	 * 不匹配: foo@bar 或 $$$@bar.com
    	 *
    	 */
    	public static final String email_regexp = "(?:\\w[-._\\w]*\\w@\\w[-._\\w]*\\w\\.\\w{2,3}$)";
    
    	/**
    	 * 匹配匹配并提取url <br>
    	 *
    	 * 格式: XXXX://XXX.XXX.XXX.XX/XXX.XXX?XXX=XXX
    	 *
    	 * 匹配 : http://www.suncer.com 或news://www<br>
    	 *
    	 * 提取(MatchResult matchResult=matcher.getMatch()):
    	 *  			matchResult.group(0)= http://www.suncer.com:8080/index.html?login=true
    	 *              matchResult.group(1) = http
    	 *              matchResult.group(2) = www.suncer.com
    	 *              matchResult.group(3) = :8080
    	 *              matchResult.group(4) = /index.html?login=true
    	 *
    	 * 不匹配: c:\window
    	 *
    	 */
    	public static final String url_regexp = "(\\w+)://([^/:]+)(:\\d*)?([^#\\s]*)";
    
    	/**
    	 * 匹配并提取http <br>
    	 *
    	 * 格式: http://XXX.XXX.XXX.XX/XXX.XXX?XXX=XXX 或 ftp://XXX.XXX.XXX 或 https://XXX
    	 *
    	 * 匹配 : http://www.suncer.com:8080/index.html?login=true<br>
    	 *
    	 * 提取(MatchResult matchResult=matcher.getMatch()):
    	 *  			matchResult.group(0)= http://www.suncer.com:8080/index.html?login=true
    	 *              matchResult.group(1) = http
    	 *              matchResult.group(2) = www.suncer.com
    	 *              matchResult.group(3) = :8080
    	 *              matchResult.group(4) = /index.html?login=true
    	 *
    	 * 不匹配: news://www
    	 *
    	 */
    	public static final String http_regexp = "(http|https|ftp)://([^/:]+)(:\\d*)?([^#\\s]*)";
    
    	/**
    	 * 匹配日期 <br>
    	 *
    	 * 格式(首位不为0): XXXX-XX-XX 或 XXXX XX XX 或 XXXX-X-X <br>
    	 *
    	 * 范围:1900--2099 <br>
    	 *
    	 * 匹配 : 2005-04-04 <br>
    	 *
    	 * 不匹配: 01-01-01
    	 *
    	 */
    	public static final String date_regexp = "^((((19){1}|(20){1})d{2})|d{2})[-\\s]{1}[01]{1}d{1}[-\\s]{1}[0-3]{1}d{1}$";
            // 匹配日期
    
    	/**
    	 * 匹配电话 <br>
    	 *
    	 * 格式为: 0XXX-XXXXXX(10-13位首位必须为0) 或0XXX XXXXXXX(10-13位首位必须为0) 或 <br>
    	 * (0XXX)XXXXXXXX(11-14位首位必须为0) 或 XXXXXXXX(6-8位首位不为0) 或
    	 * XXXXXXXXXXX(11位首位不为0) <br>
    	 *
    	 * 匹配 : 0371-123456 或 (0371)1234567 或 (0371)12345678 或 010-123456 或
    	 * 010-12345678 或 12345678912 <br>
    	 *
    	 * 不匹配: 1111-134355 或 0123456789
    	 *
    	 */
    	public static final String phone_regexp = "^(?:0[0-9]{2,3}[-\\s]{1}|\\(0[0-9]{2,4}\\))[0-9]{6,8}$|^[1-9]{1}[0-9]{5,7}$|^[1-9]{1}[0-9]{10}$";
    
    	/**
    	 * 匹配身份证 <br>
    	 *
    	 * 格式为: XXXXXXXXXX(10位) 或 XXXXXXXXXXXXX(13位) 或 XXXXXXXXXXXXXXX(15位) 或
    	 * XXXXXXXXXXXXXXXXXX(18位) <br>
    	 *
    	 * 匹配 : 0123456789123 <br>
    	 *
    	 * 不匹配: 0123456
    	 *
    	 */
    	public static final String ID_card_regexp = "^\\d{10}|\\d{13}|\\d{15}|\\d{18}$";
    
    	/**
    	 * 匹配邮编代码 <br>
    	 *
    	 * 格式为: XXXXXX(6位) <br>
    	 *
    	 * 匹配 : 012345 <br>
    	 *
    	 * 不匹配: 0123456
    	 *
    	 */
    	public static final String ZIP_regexp = "^[0-9]{6}$";// 匹配邮编代码
    
    
    	/**
    	 * 不包括特殊字符的匹配 (字符串中不包括符号 数学次方号^ 单引号' 双引号" 
             * 分号; 逗号, 帽号: 数学减号- 右尖括号> 左尖括号<  反斜杠\ 即空格,制表符,回车符等 )<br>
    	 *
    	 * 格式为: x 或 一个一上的字符 <br>
    	 *
    	 * 匹配 : 012345 <br>
    	 *
    	 * 不匹配: 0123456
    	 *
    	 */
    	public static final String non_special_char_regexp = "^[^'\"\\;,:-<>\\s].+$";// 匹配邮编代码
    
    
    	/**
    	 * 匹配非负整数(正整数 + 0)
    	 */
    	public static final String non_negative_integers_regexp = "^\\d+$";
    
    	/**
    	 * 匹配不包括零的非负整数(正整数 > 0)
    	 */
    	public static final String non_zero_negative_integers_regexp = "^[1-9]+\\d*$";
    
    	/**
    	 *
    	 * 匹配正整数
    	 *
    	 */
    	public static final String positive_integer_regexp = "^[0-9]*[1-9][0-9]*$";
    
    	/**
    	 *
    	 * 匹配非正整数(负整数 + 0)
    	 *
    	 */
    	public static final String non_positive_integers_regexp = "^((-\\d+)|(0+))$";
    
    	/**
    	 *
    	 * 匹配负整数
    	 *
    	 */
    	public static final String negative_integers_regexp = "^-[0-9]*[1-9][0-9]*$";
    
    	/**
    	 *
    	 * 匹配整数
    	 *
    	 */
    	public static final String integer_regexp = "^-?\\d+$";
    
    	/**
    	 *
    	 * 匹配非负浮点数(正浮点数 + 0)
    	 *
    	 */
    	public static final String non_negative_rational_numbers_regexp = "^\\d+(\\.\\d+)?$";
    
    	/**
    	 *
    	 * 匹配正浮点数
    	 *
    	 */
    	public static final String positive_rational_numbers_regexp = "^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$";
    
    	/**
    	 *
    	 * 匹配非正浮点数(负浮点数 + 0)
    	 *
    	 */
    	public static final String non_positive_rational_numbers_regexp = "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$";
    
    	/**
    	 *
    	 * 匹配负浮点数
    	 *
    	 */
    	public static final String negative_rational_numbers_regexp = "^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$";
    
    	/**
    	 *
    	 * 匹配浮点数
    	 *
    	 */
    	public static final String rational_numbers_regexp = "^(-?\\d+)(\\.\\d+)?$";
    
    	/**
    	 *
    	 * 匹配由26个英文字母组成的字符串
    	 *
    	 */
    	public static final String letter_regexp = "^[A-Za-z]+$";
    
    	/**
    	 *
    	 * 匹配由26个英文字母的大写组成的字符串
    	 *
    	 */
    	public static final String upward_letter_regexp = "^[A-Z]+$";
    
    	/**
    	 *
    	 * 匹配由26个英文字母的小写组成的字符串
    	 *
    	 */
    	public static final String lower_letter_regexp = "^[a-z]+$";
    
    	/**
    	 *
    	 * 匹配由数字和26个英文字母组成的字符串
    	 *
    	 */
    	public static final String letter_number_regexp = "^[A-Za-z0-9]+$";
    
    	/**
    	 *
    	 * 匹配由数字、26个英文字母或者下划线组成的字符串
    	 *
    	 */
    	public static final String letter_number_underline_regexp = "^\\w+$";
    
    	/**
    	 * 添加正规表达式 (以key->value的形式存储)
    	 *
    	 * @param regexpName
    	 *            该正规表达式名称 `
    	 * @param regexp
    	 *            该正规表达式内容
    	 */
    	public void putRegexpHash(String regexpName, String regexp)
           {
    		regexpHash.put(regexpName, regexp);
    	}
    
    	/**
    	 * 得到正规表达式内容 (通过key名提取出value[正规表达式内容])
    	 *
    	 * @param regexpName
    	 *            正规表达式名称
    	 *
    	 * @return 正规表达式内容
    	 */
    	public String getRegexpHash(String regexpName)
            {
    		if (regexpHash.get(regexpName) != null)
                    {
    			return ((String) regexpHash.get(regexpName));
    		}
                    else
                    {
    			System.out.println("在regexpHash中没有此正规表达式");
    			return "";
    		}
    	}
    
    	/**
    	 * 清除正规表达式存放单元
    	 */
    	public void clearRegexpHash()
            {
    		regexpHash.clear();
    		return;
    	}
    
    	/**
    	 * 大小写敏感的正规表达式批配
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回真,否则返回假 
             * 如:  Regexp.isHardRegexpValidate("ygj@suncer.com.cn",email_regexp) 返回真
    	 */
    	public static boolean isHardRegexpValidate(String source, String regexp)
    	{
    		try
    		{
    			// 用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    
    			// 实例大小大小写敏感的正规表达式模板
    			Pattern hardPattern = compiler.compile(regexp);
    
    			// 返回批配结果
    			return matcher.contains(source, hardPattern);
    		} catch (MalformedPatternException e){
    			e.printStackTrace();
    		}
    		return false;
    	}
    
    	/**
    	 * 不区分大小写的正规表达式批配
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回真,否则返回假 
             * 例如:Regexp.isHardRegexpValidate("ygj@suncer.com.cn",email_regexp) 返回真
    	 */
    	public static boolean isSoftRegexpValidate(String source, String regexp)
    	{
    		try
    		{
    			//用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    
    			// 实例不区分大小写的正规表达式模板
    			Pattern softPattern = compiler.compile(regexp,
    					Perl5Compiler.CASE_INSENSITIVE_MASK);
    
    			// 返回批配验证值
    			return matcher.contains(source, softPattern);
    
    		}catch (MalformedPatternException e){
    			e.printStackTrace();
    		}
    		return false;
    	}
    
    	/**
    	 * 返回许要的批配结果集(大小写敏感的正规表达式批配)
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回许要的批配结果集,否则返回 "null"关键字 <br>
    	 *         如 : MatchResult matchResult = 
             *              getHardRegexpMatchResult("http://www.suncer.com:8080/index.html?login=true",Regexp.url_regexp)
    	 *         得到取出的匹配值为
    	 *  		matchResult.group(0)= http://www.suncer.com:8080/index.html?login=true
    	 *              matchResult.group(1) = http
    	 *              matchResult.group(2) = www.suncer.com
    	 *              matchResult.group(3) = :8080
    	 *              matchResult.group(4) = /index.html?login=true
    	 *
    	 */
    	public static MatchResult getHardRegexpMatchResult(String source, String regexp)
    	{
    		try
    		{
    			//用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    
    			// 实例大小大小写敏感的正规表达式模板
    			Pattern hardPattern = compiler.compile(regexp);
    
    			// 如果批配结果正确,返回取出的批配结果
    			if (matcher.contains(source, hardPattern))
                            {
    				// MatchResult result=matcher.getMatch();
    				return matcher.getMatch();
    			}
    		}catch (MalformedPatternException e){
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 返回许要的批配结果集(不区分大小写的正规表达式批配)
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回许要的批配结果集,否则返回 "null"关键字
             *  如 : MatchResult matchResult = 
             *       getHardRegexpMatchResult("http://www.suncer.com:8080/index.html?login=true",Regexp.url_regexp)
    	 *         得到取出的匹配值为
    	 *  		matchResult.group(0)= http://www.suncer.com:8080/index.html?login=true
    	 *              matchResult.group(1) = http
    	 *              matchResult.group(2) = www.suncer.com
    	 *              matchResult.group(3) = :8080
    	 *              matchResult.group(4) = /index.html?login=true
    	 */
    	public static MatchResult getSoftRegexpMatchResult(String source, String regexp)
    	{
    		try
    		{
    			//用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    
    			// 实例不区分大小写的正规表达式模板
    			Pattern softPattern = compiler.compile(regexp,
    					Perl5Compiler.CASE_INSENSITIVE_MASK);
    
    			// 如果批配结果正确,返回取出的批配结果
    			if (matcher.contains(source, softPattern))
                            {
    				// MatchResult result=matcher.getMatch();
    				return matcher.getMatch();
    			}
    		}catch (MalformedPatternException e){
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 返回许要的批配结果集(大小写敏感的正规表达式批配)
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回许要的批配结果集,
             * {@link #getHardRegexpMatchResult(String, String) 使用方法参见getHardRegexpMatchResult(String, String)}
    	 */
    	public static ArrayList getHardRegexpArray(String source, String regexp)
    	{
    		List tempList=new ArrayList();
    		try
    		{
    			//用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    
    			// 实例大小大小写敏感的正规表达式模板
    			Pattern hardPattern = compiler.compile(regexp);
    
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    
    			// 如果批配结果正确,返回取出的批配结果
    			if (matcher.contains(source, hardPattern))
    			{
    				//存放取出值的正规表达式比较批配结果对象
    				MatchResult matchResult =matcher.getMatch();
    				for(int i=0;i<matchResult.length() && matchResult.group(i)!=null; i++)
    				{
    					tempList.add(i,matchResult.group(i));
    				}
    			}
    		}catch (MalformedPatternException e){
    			e.printStackTrace();
    		}
    		return (ArrayList)tempList;
    	}
    
    	/**
    	 * 返回许要的批配结果集(不区分大小写的正规表达式批配)
    	 *
    	 * @param source
    	 *            批配的源字符串
    	 *
    	 * @param regexp
    	 *            批配的正规表达式
    	 *
    	 * @return 如果源字符串符合要求返回许要的批配结果集
             * {@link #getHardRegexpMatchResult(String, String) 使用方法参见getHardRegexpMatchResult(String, String)}
    	 */
    	public static ArrayList getSoftRegexpArray(String source, String regexp)
    	{
    		List tempList=new ArrayList();
    
    		try
    		{
    			//用于定义正规表达式对象模板类型
    			PatternCompiler compiler = new Perl5Compiler();
    			// 正规表达式比较批配对象
    			PatternMatcher matcher = new Perl5Matcher();
    			//实例不区分大小写的正规表达式模板
    			Pattern softPattern =  compiler.compile(regexp,Perl5Compiler.CASE_INSENSITIVE_MASK);
    
    			if (matcher.contains(source, softPattern))
    			{
    				// 如果批配结果正确,返回取出的批配结果
    				MatchResult matchResult=matcher.getMatch();
    				for(int i=0;i<matchResult.length() && matchResult.group(i)!=null; i++)
    				{
    					tempList.add(i,matchResult.group(i));
    				}
    			}
    		}
    		catch (MalformedPatternException e)
    		{
    			e.printStackTrace();
    		}
    		return (ArrayList)tempList;
    }
    
      /**
       * <pre>
       * 得到指定分隔符中间的字符串的集合,
       *              说明: 1.分隔符为 (),[],{},<> 中的一组
       *                        2.得到的集合以 ASCII 的升序排列
       *              如       String originStr="((([a]+[b])/[c])-24)+[d]";
       *              则          getStrBetweenSeparator(originStr,"[","]"));
       *                           返回结果集合有四个元素  [a, b, c, d],
       *                          以 ASCII 的升序排列
       * </pre>
       *
       * @param originStr
       *                         要提取的源字符串
       * @param leftSeparator
       *                         左边的分隔符
       * @param rightSeparator
       *                        右边的分隔符
       * @return
       *                    指定分隔符中间的字符串的集合
       */
      public static Set getBetweenSeparatorStr(final String originStr,final char leftSeparator,final char rightSeparator)
      {
                Set  variableSet=new TreeSet();
                if(StringHelp.isEmpty(originStr))
                {
                    return variableSet;
                }
                 String sTempArray[]=originStr.split("(\\"+leftSeparator+")");
                 for(int i=1;i<sTempArray.length;i++)
                 {
                             int endPosition= sTempArray[i].indexOf(rightSeparator);
                              String sTempVariable=sTempArray[i].substring(0,endPosition);
                              variableSet.add(sTempVariable);
                 }
            return variableSet;
      }
    	public static void main(String a[])
    	{
            /*
    		PatternCompiler compiler = new Perl5Compiler();
    		PatternMatcher matcher = new Perl5Matcher();
    		MatchResult matchResult=matcher.getMatch();
    		String email = "wuzhi2000@hotmail.com.cn";
    		String email_regexp = "^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$";
    		String url = "http://www";
    		String url_regexp = "^(?:http|https|ftp)://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$";// 匹配url
    		String date = "1111-1-9";
    		String date_regexp = "^[1-9]{1}[0-9]{0,3}[-\\s][0-9]{1,2}[-\\s][0-9]{1,2}$";// 匹配日期
    		String phone = "010-1234567";
    		String phone_regexp = "^(?:0[0-9]{2,4}[-\\s]{1}|\\(0[0-9]{2,4}\\))[0-9]{6,8}$|^[0-9]{6,8}$";// 匹配电话
    		String icon="/he//fff/aaaq34.gif";
    		String icon_regexp = "^(/{0,1}\\w){1,}\\.(gif|dmp|png)$|^\\w{1,}\\.(gif|dmp|png)$";
    		String name="\"^";
    		String number="023";
    		String pic ="forum/head_icons/anoymous20050428125334.jpg";
    		System.out.println(Regexp.isSoftRegexpValidate(pic,Regexp.icon_regexp));
              */
    
                /*
    	try{
                  PatternCompiler compiler = new Perl5Compiler();
                  PatternMatcher matcher = new Perl5Matcher();
                  MatchResult matchResult=matcher.getMatch();
    
                  //一个提取html标签属性的例子
                  String regexpForFontTag="<\\s*font\\s+([^>]*)\\s*>";
                  String  regexpForFontAttrib="([a-z]+)\\s*=\\s*\"([^\"]+)\"";
    
                  String html=" <font face=\"Arial, serif\" size=\"+2\" color=\"red\">";
                  System.out.println(regexpForFontTag);
                  System.out.println(regexpForFontAttrib); System.out.println(html);
    
                  Pattern p1=compiler.compile(regexpForFontTag,Perl5Compiler.CASE_INSENSITIVE_MASK);
                  Pattern p2=compiler.compile(regexpForFontAttrib,Perl5Compiler.CASE_INSENSITIVE_MASK);
                  System.out.println(matcher.contains(html,p1));
                  if(matcher.contains(html,p1))
                  {
                              MatchResult
                              result=matcher.getMatch(); System.out.println(result.group(1));
                              String attribs=result.group(1);
    
                              PatternMatcherInput input =new PatternMatcherInput(attribs);
                              System.out.println(matcher.contains(input,p2));
                              while(matcher.contains(input,p2))
                              {
                                       result=matcher.getMatch();
                                       System.out.println(result.group(1)+" : "+result.group(2));
                               }
                  }
    	} catch(MalformedPatternException e){
                  e.printStackTrace();
    	}
            */
    
            /*
            //一个提取http的例子 String
    	try{
                      PatternCompiler compiler = new Perl5Compiler();
                      PatternMatcher matcher = new Perl5Matcher();
                      MatchResult matchResult=matcher.getMatch();
                      String http="http://www.suncer.com:8080/index.html?login=true";
                      String http_regexp="(\\w+)://([^/:]+)(:\\d*)?([^#\\s]*)";
                      Pattern  p1=compiler.compile(http_regexp,Perl5Compiler.CASE_INSENSITIVE_MASK);
                      System.out.println(matcher.contains(http,p1));
                      if(matcher.contains(http,p1))
                      {
                          MatchResult  result=matcher.getMatch();
                          System.out.println(result.group(1));
                          String attribs=result.group(1);
    
                          for( int i=0;i <result.length() && result.group(i)!=null; i++)
                          {
                               System.out.println(i+" : "+result.group(i));
                          }
                    }
    	}catch(MalformedPatternException e) {
                  e.printStackTrace();
    	}
            */
    
            //一个提取字符串中的中括号 [ ] 包含的字符的例子
            String expression="((([a]+[b])/[c])-24)+[d]";
            System.out.println( getBetweenSeparatorStr(expression,'[',']'));
        }
    }


    展开全文
  • java 解析数学表达式

    千次阅读 2011-11-20 10:33:57
    数学表达式解析工具类: 支持负数运算, 多层括号嵌套运算   采用堆栈实现,实现步骤: (1)除去表达式中所有空白 (2)提取表达式运算符合 (3)依据运算符合,将表达式转化为一个数组 (4)对这个数组进行...
  • java解析数学公式

    2014-11-27 11:31:12
    这个是我自己开发的用java编写的解析简单数学公式的jar, 资源下载积分有点贵,但很值得。 解析的公式可以为:+,-,*,/,max() min(),以及带()的 公式例如: 344+(344-(34+3434)/90)*45 344.34*2+343.34/3 max...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 这个表达式相对别的计算工具,优点主要体现在: A、不需要预先加载可能需要的所有属性值 B、 用户可以根据业务需要自定义操作符号和函数  C、可以同步输出判断错误信息,有利于提高业务系统在规则判断等使用场景...
  • 以前写了一个java的正规表达式java工具类,分享一下,有用到的欢迎下载使用。 如果你有常用的定义好的,且测试通过的正规表达式,欢迎跟贴,也让我享用一下 . 类中用到了 jakarta-oro-2.0.jar 包,请大家自己在 ...
  • java数据计算MyMath工具

    千次阅读 2019-01-13 16:51:28
    java 数学计算工具 java数学计算的使用性上还是比较麻烦的,遇到大量数据计算复杂的计算公式则会频发问题。接下来我们来统计一下在java中经常会遇到的计算问题 科学计数法 保留小数点问题 复杂公式处理麻烦 ...
  • 1.使用此分析器需要输入两个量: String str1=运算符号有前后有空格的数学表达式(如 1 + 2 * ( 3+1) - 5 #),并在最后添加‘#’字符作为结束标志; String str2=无空格的分割的数学表达式(如 1+2*(3+1)-5#),...
  • 最近在负责一个和定价有关的系统,要做...需要能够做表达式匹配和数学公式计算。 调研了业内很多的表达式引擎工具,如Ognl、MVEL、IKExpression、Aviator等,根据易用性、性能、可维护性、功能多少等,最终选择了Avi
  • 其他提供的很多工具类,但是缺少demo实例,让处入手的人很难直接上手使用  参考 https://github.com/nikic/PHP-Parser/blob/master/doc/component/Walking_the_AST.markdown 以后有时间在翻译一下文档 ...
  • JAVA常用工具类

    万次阅读 多人点赞 2018-09-11 22:28:32
    JAVA常用工具类(根据GITHUB代码统计) 从Google你能搜索到大量的关于Struts,Spring,Hibernate,iBatis等比较大的框架的资料,但是很少有人去关注一些小的工具包,但是当你真正知道了这些包的用处之后,你会发现它能很...
  • 构建 语法树 来解析 数学表达式

    千次阅读 2018-11-30 12:53:04
    构建 语法树 来解析 数学表达式 本文主要讲如何把一个数学表达式转化成语法树,并通过语法树来解出结果。 引入 这个主要是用来学习语法树的构建,数学表达式只是一个引子,本项目可以引申到 HTTP 请求报文解析,SQL...
  • java 表达式解析框架

    千次阅读 2015-08-07 14:24:02
    KExpressionV2.0简易表达式解析器使用说明 目录 1. IK表达式介绍(IK Expression Introduction)2. 快速入门(Quick Start)3. 表达式公式规范(Expression Formula Specification)4. 高级特性(Advance) ...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等)请往我的资源... 000 愉快的开始 ...
  • Java数学表示式解析工具- jeval

    千次阅读 2014-12-23 12:01:44
    这个包可以为我们提高高效的数学表达式计算。 举个例子:这个是我们策划给出的游戏命中率的一部份计算公式 是否命中=a命中率 – (b等级 – a等级) * (命中系数(6)* b闪避率 / 100)+32 为了好看点,我们把他变成:...
  • ",计算结果:"  + result);   }      public   static   void  test2()  throws  ScriptException {   String str =  "43*(2 + 1.4)+2*32/(3-2.1)" ;   ScriptEngineManager ...
  • java中使用正则表达式

    2016-08-26 16:13:48
    计算机专业毕业或者使用过Unix、Perl等产品的读者一定对正则表达式有一定的印象,即使没有...正则表达式最早是由数学家Stephen Kleene在对自然语言的递增研究成果的基础上提出来的,具有完整语法的正则表达式使用在字
  • 正则表达式 1.1 正则表达式简介 正则表达式,又称规则表达式。(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的...
  • apache commons常用工具类

    千次阅读 2018-07-29 17:25:27
    Commons-Discovery 提供工具来定位资源 (包括) ,通过使用各种模式来映射服务/引用名称和资源名称。. EL Commons-EL 提供在JSP2.0规范中定义的EL表达式的解释器. FileUpload FileUpload 使得在你可以...
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    配置管理流程 88 3.SVN实战 88 配置管理工具SVN操作过程手册 90 一、 如何创建“project”项目版本库 90 二、 如何查看创建的“project”项目版本库 95 三、 在版本浏览器里面,创建文件,并进行检出 99 四、 如何对...
  • Shell

    千次阅读 多人点赞 2019-08-16 22:01:18
    Shell 介绍 shell是一个用c语言编写的程序,他被称为用户使用linux的桥梁 shell即是一种命令语言,又是一种程序语言 ... shell编程和java,python等一样,只需要一个文本编辑器和解释工具即可 linux的...
  • 为了使用简单数学表达式做验证码,就要计算生成的表达式的计算结果,就去看了下数学表达式计算的方法。本来只计算简单的整型加减法的,但是最后整理了下,能计算小数。 核心算法: 以整数计算为例 public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,252
精华内容 7,700
关键字:

java计算数学表达式的工具类

java 订阅