keyset.java

这是一个用J2ME开发的计算器程序

package Calc;

import java.io.*;
import java.lang.*;
import java.util.*;

public class KeySet {
    private Func func = new Func();
    private String memo = "";                // M
    private static String[] abcdef = {"","","","","",""}; //可以赋值的6个变量
    private static String ssco = "," ,strm, strn, keys ;  //每个vector项目所记录的操作符号、数字符号
    private static String stra, strb;
    private static String x, y, z;          //计算结果时用
    private static int    decimal = -1, sswr = 5; //小数位数(小于0则全显示)、四舍五入
    private static int    maxnum = 15;      //允许的最多数值位数
    private static int    totalrecord = 100;    //允许的最多记录数，超过则删除最前面的
    private static int    rec1 = 0, rec0 = 0, reci = 0;     //当前的记录个数，分别增加的记录个数
    private static final String s10 = "-0123456789", s04 = "^+-*/", s06 = "ABCDEF";
    private boolean recadd = false;
    private boolean allownum = true;         //是否允许输入数字
    private boolean firstrun = true;
    private boolean allowset = false;
    private StrVect mn = new StrVect(totalrecord, 2);

    //private String allowall = "|0|1|2|3|4|5|6|7|8|9|.|-/+|%|=|^|+|-|*|/|(|)|sqrt|sq3|pi|e|MR|MS|MC|M+|Set|A|B|C|D|E|F|";
    //private String allowhat = "|0|1|2|3|4|5|6|7|8|9|.|(|pi|e|";
    //private String allownot = "";

    public KeySet() {
        rec0 = 0;
        rec1 = 0;
        mn.add("", "0");
    }

    public int getfirst() { return rec0; }
    public int getlast()  { return rec1; }
    public String getrecm(int i) { return mn.get(i, 0);}
    public String getrecn(int i) { return strn = func.sThree(func.trimResult(mn.get(i, 1), maxnum), ssco);}
    public String getrecn0(int i) { return strn = mn.get(i, 1);}
    public boolean allowset() { return allowset;}
    public String getmemo() { return memo; }
    public void setMaxNum(int i) { maxnum = i;}
    public String getABCDEF(int i) {
        if (i >= 6 || i < 0) {
            String s = "";
            for (int j = 0; j < 6; j++) {
                s += (abcdef[j].length() > 0 ? String.valueOf((char)(65+j))+"" : "");
            }
            return s;
        } else {
            return abcdef[i];
        }
    }

    public void setKey( String s ) {                    //主调用模块
        keys = s;
        if (allowset || keqs( "Set" )) {
            setKeyAllow();
        } else {
            setKeyInput();
        }
    }


    //public void setKey( String keys, int type ) {   //输入的符号及其类型
    private void setKeyInput( ) {
        strm = mn.get(rec1, 0);
//  = >>
        if (meqs("=")) {        //当前已经是等号
            if (keqs("=")) {    //又输入等号
                if (rec1 > 0) {
                    strm = mn.get(rec1-1, 0);
                    strn = mn.get(rec1-1, 1);
                    if (mins("^+-*/") && func.isNum(strn) && func.isNum(mn.get(rec1, 1))) {
                        mn.add("", mn.get(rec1, 1));
                        mn.add(strm, strn);
                        setrec();
                    } else { return;}
                } else { return;}
            }
            else if (keqs( "Backspace" )) {
                mn.set("", "", rec1);
            }
            else if ("|MR|MS|MC|M+|A|B|C|D|E|F|".indexOf("|"+keys+"|") >= 0 ) {
            }
            else {
                mn.add("", "");
                rec1 = mn.lastof();
                if (kins("|x^y|+|-|*|/|sqrt|sq3|")) {
                    mn.set(mn.get(rec1-1, 1), rec1, 1);
                } else {
                    allownum = true;
                    strm = "";
                    strn = "";
                }
            }
        }
        strm = mn.get(rec1, 0);    //4+1运算符号，^代表整数的次方
        strn = mn.get(rec1, 1);    //数字符号
        recadd = false;      reci = 0;
        allownum = (rec1 == 0 || mins("^+-*/("));     //是否允许输入数字
        firstrun = ((neqs("0") || nlen(0)) && rec1 == 0);
        if (len(strn) > 0) {
            if (!func.isNum(strn) && !allowset) {
                if (keqs( "Backspace" ) || keqs("CE")) { strn = "";}     //有数字、不是数字、是否删除，否则返回
                else {return ;}
            }
        }


//   =
        if         (keqs( "=" )) {
            while ( mn.occur("(", rec0, rec1 ) > mn.occur(")", rec0, rec1 ) ) {
                rec1 = mn.add( ")", "");
            }
            strn = func.trimZero(calcRecord());
            strn = func.sDecimal(strn, decimal, sswr);
            strm = "=";
            recadd = true;
        }
//   Set
        else if (keqs( "Set" )) {
            setKeyAllow();
            return;
        }
//   Backspace
        else if (keqs( "Backspace" )) {
            if (nlen(0)) { strm = "";}     //依次向前删除，删除数字后删除符号
            else { strn = func.sLess(strn, 1); }
            if (rec1 == 0 && nlen(0)) { strn = "0"; }
        }
//  (
        else if (keqs( "(" )) {//左、右括号，要判断是否能用括号。左：无数、有符、非类，或头行且无数
                if (firstrun) {strm = keys; strn = "";}
                else if (nlen(0)) {
                    if (strm.length() == 1 && (")^").indexOf(strm) < 0 || rec1 == 0 )
                        {strm = keys; strn = ""; recadd = true;}
                    else if (mlen(0)) {strm = keys; strn = "";}
                }
        }
//  )
        else if (keqs( ")" )) {//右：数值，或上一次也是括号，并且前面已有需配对儿的括号

                //if ( meqs("(") ) { strm = ""; strn = ""; recadd = -1;}  //s10.indexOf(sRight(strn,1)) > 0
                if ( ( func.isNum(strn) || func.sRight(strn,1).equals("%") || nlen(0) && meqs(")") ) && mn.occur("(", rec0, rec1 ) > mn.occur(")", rec0, rec1 ) )
                    {strm = keys; strn = ""; recadd = true;}
        }
//  CE
        else if (keqs( "CE" )) {
            strm = "";                    //清除内容
            strn = "";
        }
//  0123456789
        else if (kins("|0|1|2|3|4|5|6|7|8|9|")) {  // 0123456789
            strn = (neqs(".") ? "0." : strn);  //小数点儿加0
            strn = (neqs("0") ? "" : strn);    //前导0
            //strn = (sRight(strn,1).equals("%") ? sLess(strn, 1) : strn);
            if (allownum) {
                int dot = strn.indexOf(".");
                if (dot < 0 || (strn.length() - dot <= 15)) {
                    strn += keys;      //允许输入数字，限制小数位数
                }
            }
        }
//  pi
        else if (keqs( "pi" )) {
            if (allownum && nlen(0) || firstrun) {
                strn = Double.toString(Math.PI);
            }
        }
//  e
        else if (keqs( "e" )) {
            if (allownum && nlen(0) || firstrun) {
                strn = Double.toString(Math.E);
            }
            //strn = ( (allownum && nlen(0)) ? Double.toString(Math.E) : strn);
        }
//  %
        else if (keqs( "%" )) {
            String s1 = func.sRight(strn, 1);
            //strn = (".%".indexOf(s1) >= 0 ? sLess(strn, 1) : strn);
            //strn += ( ( s10.indexOf(sRight(strn, 1)) > 0 && !s1.equals("%") ) ? "%" : "");
            if (func.isNum(strn) && mins("+-*/") && rec1 > 0) { strn = func.trimZero(vectJJCC(mn, rec1, "%"));}    //%输入后依据上一个数直接计算出结果
        }
//  .
        else if (keqs( "." )) {
            strn = ( (nlen(0) && allownum) ? "0" : strn);  //无数、允许，则加前导0
            strn += ( ( func.isNum(strn) && strn.indexOf(".") < 0 && !meqs("^")) ? "." : "");    //是数字s10.indexOf(sRight(strn, 1))、无点儿、不是幂
        }
//  -/+
        else if (keqs( "-/+" )) {
            if ( func.sLeft(strn,1).equals("-") ) { strn = func.sLess(strn, -1); }                          //有负号则去掉，改为正数
            else if (func.isNum(strn) && !neqs("0") &&  !neqs("0.")) {strn = "-" + strn; }   //是数字、非0，则改为负数
        }
//  ABCDEF
        else if ( kins("|A|B|C|D|E|F|") ) {
            if (allownum && nlen(0) || firstrun) {
                strn = abcdef[keys.charAt(0) - 65];
            } else {
                abcdef[keys.charAt(0) - 65] = strn;
            }
        }
//  + - * /
        else if ( "|+|-|*|/|".indexOf(keys) > 0 ) {
            if (func.isNum(strn) || meqs(")") ) { recadd = true; strn = ""; strm = keys; }      //数字、右括号
            else if ( kins("^+-*/") && !neqs("(") && nlen(0) ) {strm = keys; }
        }
//  x^y
        else if (keqs( "x^y" ) || keqs("^")) {
            if (func.isNum(strn)) { recadd = true;}         //数字才有幂运算
            strm = "^";
            strn = "";
        }
//  sqrt
        else if (keqs( "sqrt" )) {
            strn = (func.isNum(strn) ? func.trimZero(strJJCC(strn, "0", keys)) : strn);   //开方
        }
//  sq3
        else if (keqs( "sq3" )) {
            strn = (func.isNum(strn) ? func.trimZero(strJJCC(strn, "0", keys)) : strn);   //开方
        }
//  MC
        else if (keqs( "MC" )) {
            memo = "";
        }
//  MS
        else if (keqs( "MS" )) {
            memo = strn;
        }
//  M+
        else if (keqs( "M+" )) {
            memo = func.trimZero(strJJCC(memo, strn, "+"));
        }
//  MR
        else if (keqs( "MR" )) {
            if ( allownum && memo.length() > 0) {strn = memo;}
        }
        else if (kins("Lsh,sin,int,Hyp,cos,Mod,Dec,tan,dms,Oct,Bin")) {
        }
        else {
            strn += keys;
        }


        if (mlen(0) && nlen(0) && rec1 > 0) {
            mn.delete(rec1);    rec1 = mn.lastof();   //删除空的
        } else {
            if (recadd) {rec1 = mn.add(strm, strn);}
            else {mn.set(strm, strn, rec1);}
        }

        setrec();

    }


    private void setKeyAllow( ) {
        strm = mn.get(rec1, 0);
        strn = mn.get(rec1, 1);
        if (allowset) {
            if (keqs("=") || keqs("Set")) {
                allowset = !allowset;
                mn.set("", "", rec1);
                stra = strn + (strn.length() > 0 ? "=" : "");
                for (int i = 0; i < stra.length(); i++) {
                    strb = stra.substring(i, i+1);
                    if ("ABCDEF".indexOf(strb) >= 0) {
                        strb = abcdef[strb.charAt(0) - 65];
                        strb = (strb.length() == 0 ? "0" : strb);