在好例子网,分享、交流、成长!
您当前所在位置:首页Java 开发实例Android平台开发 → android 计算器源码(计算,三角,函数,记忆)

android 计算器源码(计算,三角,函数,记忆)

Android平台开发

下载此实例
  • 开发语言:Java
  • 实例大小:0.42M
  • 下载次数:11
  • 浏览次数:108
  • 发布时间:2021-01-13
  • 实例类别:Android平台开发
  • 发 布 人:819_lucky
  • 文件格式:.rar
  • 所需积分:2
 相关标签: 计算器 计算

实例介绍

【实例简介】

【实例截图】

from clipboard

【核心代码】package com.supermario.jisuanqi;

//import java.text.NumberFormat;
import java.text.DecimalFormat;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.util.Log;
import android.view.View.*;
import android.view.*;
import java.util.*;

public class Jisuanqi extends Activity
{
//0~9十个按键
    private Button[] btn = new Button[10];
    //显示器,用于显示输出结果
    private EditText input;
    //显示器下方的记忆器,用于记录上一次计算结果
    private TextView mem;
    //三角计算时标志显示:角度还是弧度
    private TextView _drg;
    //小提示,用于加强人机交互的弱检测、提示 
    private TextView tip;                            
    private Button
        div, mul, sub, add, equal,            // ÷ × - =
        sin, cos, tan, log, ln,               //函数
        sqrt, square, factorial, bksp,    //根号  平方  阶乘   退格
        left, right, dot, exit, drg,          //(     )  .  退出     角度弧度控制键
        mc, c;                                // mem清屏键    input清屏键
    //保存原来的算式样子,为了输出时好看,因计算时,算式样子被改变
    public String str_old;
    //变换样子后的式子
    public String str_new;
    //输入控制,true为重新输入,false为接着输入
    public boolean vbegin = true;
    //控制DRG按键,true为角度,false为弧度
    public boolean drg_flag = true;
    //π值:3.14
    public double pi=4*Math.atan(1);
    //true表示正确,可以继续输入;false表示有误,输入被锁定
    public boolean tip_lock = true;
    //判断是否是按=之后的输入,true表示输入在=之前,false反之
    public boolean equals_flag = true;  

    public void onCreate(Bundle icicle)
    {
        super.onCreate(icicle);
        setContentView(R.layout.main);
        //获取界面元素
        input = (EditText)findViewById(R.id.input);
        mem = (TextView)findViewById(R.id.mem);
        tip = (TextView)findViewById(R.id.tip); 
        _drg = (TextView)findViewById(R.id._drg);
        btn[0] = (Button)findViewById(R.id.zero);
         btn[1] = (Button)findViewById(R.id.one);
         btn[2] = (Button)findViewById(R.id.two);
         btn[3] = (Button)findViewById(R.id.three);
         btn[4] = (Button)findViewById(R.id.four);
         btn[5] = (Button)findViewById(R.id.five);
         btn[6] = (Button)findViewById(R.id.six);
         btn[7] = (Button)findViewById(R.id.seven);
        btn[8] = (Button)findViewById(R.id.eight);
        btn[9] = (Button)findViewById(R.id.nine);
        div = (Button)findViewById(R.id.divide);
        mul = (Button)findViewById(R.id.mul);
        sub = (Button)findViewById(R.id.sub);
        add = (Button)findViewById(R.id.add);
        equal = (Button)findViewById(R.id.equal);
        sin = (Button)findViewById(R.id.sin);
        cos = (Button)findViewById(R.id.cos);
        tan = (Button)findViewById(R.id.tan);
        log = (Button)findViewById(R.id.log);
        ln = (Button)findViewById(R.id.ln);
        sqrt = (Button)findViewById(R.id.sqrt);
        square = (Button)findViewById(R.id.square);
        factorial = (Button)findViewById(R.id.factorial);
        bksp = (Button)findViewById(R.id.bksp);
        left = (Button)findViewById(R.id.left);
        right = (Button)findViewById(R.id.right);
        dot = (Button)findViewById(R.id.dot);
        exit = (Button)findViewById(R.id.exit);
        drg = (Button)findViewById(R.id.drg);
        mc = (Button)findViewById(R.id.mc);
        c = (Button)findViewById(R.id.c);
        //为数字按键绑定监听器
        for(int i = 0; i < 10; i) {
            btn[i].setOnClickListener(actionPerformed);
        }
        //为 -x÷等按键绑定监听器
        div.setOnClickListener(actionPerformed);
        mul.setOnClickListener(actionPerformed);
        sub.setOnClickListener(actionPerformed);
        add.setOnClickListener(actionPerformed);
        equal.setOnClickListener(actionPerformed);
        sin.setOnClickListener(actionPerformed);
        cos.setOnClickListener(actionPerformed);
        tan.setOnClickListener(actionPerformed);
        log.setOnClickListener(actionPerformed);
        ln.setOnClickListener(actionPerformed);
        sqrt.setOnClickListener(actionPerformed);
        square.setOnClickListener(actionPerformed);    
        factorial.setOnClickListener(actionPerformed);
        bksp.setOnClickListener(actionPerformed);    
        left.setOnClickListener(actionPerformed);
        right.setOnClickListener(actionPerformed);
        dot.setOnClickListener(actionPerformed);    
        exit.setOnClickListener(actionPerformed);
        drg.setOnClickListener(actionPerformed);
        mc.setOnClickListener(actionPerformed);    
        c.setOnClickListener(actionPerformed);
    }
    
    /*
     * 键盘命令捕捉
     */
    //命令缓存,用于检测输入合法性
    String[] Tipcommand = new String[500]; 
    //Tipcommand的指针
    int tip_i = 0;         
    private OnClickListener actionPerformed = new OnClickListener() {
        public void onClick(View v) {
        //按键上的命令获取
            String command = ((Button)v).getText().toString();
            //显示器上的字符串
            String str = input.getText().toString();  
            //检测输入是否合法
            if(equals_flag == false && "0123456789.()sincostanlnlogn! -×÷√^".indexOf(command) != -1) {
            //检测显示器上的字符串是否合法
                if(right(str)) {
                    if(" -×÷√^)".indexOf(command) != -1) {
                        for(int i =0 ; i < str.length(); i ) {
                            Tipcommand[tip_i] = String.valueOf(str.charAt(i));
                            tip_i ;
                        }
                        vbegin = false;
                    }
                } else {
                    input.setText("0");
                    vbegin = true;
                    tip_i = 0;
                    tip_lock = true;
                    tip.setText("欢迎使用!");
                }

                equals_flag = true;
            }
            if(tip_i > 0)
                TipChecker(Tipcommand[tip_i-1] , command);
            else if(tip_i == 0) {
                    TipChecker("#" , command);
            }
            if("0123456789.()sincostanlnlogn! -×÷√^".indexOf(command) != -1 && tip_lock) {
                Tipcommand[tip_i] = command;
                tip_i ;
            } 
            //若输入正确,则将输入信息显示到显示器上
            if("0123456789.()sincostanlnlogn! -×÷√^".indexOf(command) != -1 
                    && tip_lock) { //共25个按键
                print(command);
            //若果点击了“DRG”,则切换当前弧度角度制,并将切换后的结果显示到按键上方。
            } else if(command.compareTo("DRG") == 0 && tip_lock) {
                if(drg_flag == true) {
                    drg_flag = false;
                    _drg.setText("   RAD");
                } else {
                    drg_flag = true;
                    _drg.setText("   DEG");
                }
                //如果输入时退格键,并且是在按=之前
            } else if(command.compareTo("Bksp") == 0 && equals_flag) {
            //一次删除3个字符
                if(TTO(str) == 3) {
                    if(str.length() > 3)
                        input.setText(str.substring(0, str.length() - 3)); 
                    else if(str.length() == 3) {
                        input.setText("0");   
                        vbegin = true;
                        tip_i = 0;
                        tip.setText("欢迎使用!");
                    }
                //依次删除2个字符
                } else if(TTO(str) == 2) {
                    if(str.length() > 2)
                        input.setText(str.substring(0, str.length() - 2)); 
                    else if(str.length() == 2) {
                        input.setText("0");   
                        vbegin = true;
                        tip_i = 0;
                        tip.setText("欢迎使用!");
                    }
                //依次删除一个字符
                } else if(TTO(str) == 1) {
                //若之前输入的字符串合法则删除一个字符
                    if(right(str)) {
                        if(str.length() > 1)
                            input.setText(str.substring(0, str.length() - 1)); 
                        else if(str.length() == 1) {
                            input.setText("0");   
                            vbegin = true;
                            tip_i = 0;
                            tip.setText("欢迎使用!");
                        }
                        //若之前输入的字符串不合法则删除全部字符
                    } else {
                        input.setText("0");   
                        vbegin = true;
                        tip_i = 0;
                        tip.setText("欢迎使用!");
                    }
                }
                if(input.getText().toString().compareTo("-") == 0 || equals_flag == false) {
                    input.setText("0");
                    vbegin = true;
                    tip_i = 0;
                    tip.setText("欢迎使用!");
                }
                tip_lock = true;
                if(tip_i > 0)
                    tip_i--;
            //如果是在按=之后输入退格键
            } else if(command.compareTo("Bksp") == 0 && equals_flag ==false) {
            //将显示器内容设置为0
                input.setText("0");
                vbegin = true;
                tip_i = 0;
                tip_lock = true;
                tip.setText("欢迎使用!");
            //如果输入的是清除键
            } else if(command.compareTo("C") == 0) {
            //将显示器内容设置为0
                input.setText("0");
                //重新输入标志置为true
                vbegin = true;
                //缓存命令位数清0
                tip_i = 0;
                //表明可以继续输入
                tip_lock = true;
                //表明输入=之前
                equals_flag = true;
                tip.setText("欢迎使用!");
                //如果输入的是”MC“,则将存储器内容清0
            } else if(command.compareTo("MC") == 0) {
                mem.setText("0");
                //如果按”exit“则退出程序
            } else if(command.compareTo("exit") == 0) {
                System.exit(0);
            //如果输入的是=号,并且输入合法
            } else if(command.compareTo("=") == 0 && tip_lock && right(str) && equals_flag) {
                tip_i = 0;
                //表明不可以继续输入
                tip_lock = false;
                //表明输入=之后
                equals_flag = false;
                //保存原来算式样子
                str_old = str;
                //替换算式中的运算符,便于计算
                str = str.replaceAll("sin", "s");
                str = str.replaceAll("cos", "c");
                str = str.replaceAll("tan", "t");
                str = str.replaceAll("log", "g");
                str = str.replaceAll("ln", "l");
                str = str.replaceAll("n!", "!");
                //重新输入标志设置true
                vbegin = true;
                //将-1x转换成-
                str_new = str.replaceAll("-", "-1×");
                //计算算式结果
                new calc().process(str_new);
            }
            //表明可以继续输入
            tip_lock = true;
        }
    };
    //向input输出字符
    private void print(String str) {
    //清屏后输出
        if(vbegin)
            input.setText(str);
        //在屏幕原str后增添字符
        else
            input.append(str);
        vbegin = false;
    }  
    /*
     * 判断一个str是否是合法的,返回值为true、false
     * 只包含0123456789.()sincostanlnlogn! -×÷√^的是合法的str,返回true
     * 包含了除0123456789.()sincostanlnlogn! -×÷√^以外的字符的str为非法的,返回false
     */
    private boolean right(String str) {
        int i = 0;
        for(i = 0;i < str.length();i ) {
            if(str.charAt(i)!='0' && str.charAt(i)!='1' && str.charAt(i)!='2' && 
                    str.charAt(i)!='3' && str.charAt(i)!='4' && str.charAt(i)!='5' && 
                    str.charAt(i)!='6' && str.charAt(i)!='7' && str.charAt(i)!='8' && 
                    str.charAt(i)!='9' && str.charAt(i)!='.' && str.charAt(i)!='-' &&
                    str.charAt(i)!=' ' && str.charAt(i)!='×' && str.charAt(i)!='÷' &&
                    str.charAt(i)!='√' && str.charAt(i)!='^' && str.charAt(i)!='s' &&
                    str.charAt(i)!='i' && str.charAt(i)!='n' && str.charAt(i)!='c' &&
                    str.charAt(i)!='o' && str.charAt(i)!='t' && str.charAt(i)!='a' &&
                    str.charAt(i)!='l' && str.charAt(i)!='g' && str.charAt(i)!='(' &&
                    str.charAt(i)!=')' && str.charAt(i)!='!') 
                break;
        }
        if(i == str.length()) {
            return true;
        } else {
            return false;
        }
    }
    /*
     * 检测函数,返回值为3、2、1  表示应当一次删除几个?  Three Two One = TTO
     * 为Bksp按钮的删除方式提供依据
     * 返回3,表示str尾部为sin、cos、tan、log中的一个,应当一次删除3个
     * 返回2,表示str尾部为ln、n!中的一个,应当一次删除2个
     * 返回1,表示为除返回3、2外的所有情况,只需删除一个(包含非法字符时要另外考虑:应清屏)
     */
    private int TTO(String str) {  
        if((str.charAt(str.length() - 1) == 'n' && 
                str.charAt(str.length() - 2) == 'i' &&
                str.charAt(str.length() - 3) == 's') ||
                (str.charAt(str.length() - 1) == 's' && 
                str.charAt(str.length() - 2) == 'o' &&
                str.charAt(str.length() - 3) == 'c') ||
                (str.charAt(str.length() - 1) == 'n' && 
                str.charAt(str.length() - 2) == 'a' &&
                str.charAt(str.length() - 3) == 't') ||
                (str.charAt(str.length() - 1) == 'g' && 
                str.charAt(str.length() - 2) == 'o' &&
                str.charAt(str.length() - 3) == 'l')) {
            return 3;
        } else if((str.charAt(str.length() - 1) == 'n' && 
                        str.charAt(str.length() - 2) == 'l') ||
                        (str.charAt(str.length() - 1) == '!' && 
                        str.charAt(str.length() - 2) == 'n')) {
                    return 2;
        } else { return 1; }
    }  
    /*
     * 检测函数,对str进行前后语法检测
     * 为Tip的提示方式提供依据,与TipShow()配合使用
     *  编号 字符    其后可以跟随的合法字符
     *   1  (                 数字|(|-|.|函数
     *   2   )                算符|)|√ ^
     *   3  .      数字|算符|)|√ ^
     *   4   数字        .|数字|算符|)|√ ^
     *   5   算符             数字|(|.|函数
     *   6 √ ^     ( |. | 数字
     *   7  函数           数字|(|.
     *   
     * 小数点前后均可省略,表示0
     * 数字第一位可以为0
     */
    private void TipChecker(String tipcommand1,String tipcommand2) {
    //Tipcode1表示错误类型,Tipcode2表示名词解释类型
    int Tipcode1 = 0 , Tipcode2 = 0;
        //表示命令类型
        int tiptype1 = 0 , tiptype2 = 0;
        //括号数
        int bracket = 0;
        //“ -x÷√^”不能作为第一位
        if(tipcommand1.compareTo("#") == 0 && (tipcommand2.compareTo("÷") == 0 || 
                tipcommand2.compareTo("×") == 0 || tipcommand2.compareTo(" ") == 0 || 
                tipcommand2.compareTo(")") == 0 || tipcommand2.compareTo("√") == 0 ||
                tipcommand2.compareTo("^") == 0)) {
            Tipcode1 = -1;
        }
        //定义存储字符串中最后一位的类型
        else if(tipcommand1.compareTo("#") != 0) {
            if(tipcommand1.compareTo("(") == 0) {
                tiptype1 = 1;
            } else if(tipcommand1.compareTo(")") == 0) {
                tiptype1 = 2;
            } else if(tipcommand1.compareTo(".") == 0) {
                tiptype1 = 3;
            } else if("0123456789".indexOf(tipcommand1) != -1) {
                tiptype1 = 4;
            } else if(" -×÷".indexOf(tipcommand1) != -1) {
                tiptype1 = 5;
            } else if("√^".indexOf(tipcommand1) != -1) {
                tiptype1 = 6;
            } else if("sincostanloglnn!".indexOf(tipcommand1) != -1) {
                tiptype1 = 7;
            }
            //定义欲输入的按键类型
            if(tipcommand2.compareTo("(") == 0) {
                tiptype2 = 1;
            } else if(tipcommand2.compareTo(")") == 0) {
                tiptype2 = 2;
            } else if(tipcommand2.compareTo(".") == 0) {
                tiptype2 = 3;
            } else if("0123456789".indexOf(tipcommand2) != -1) {
                tiptype2 = 4;
            } else if(" -×÷".indexOf(tipcommand2) != -1) {
                tiptype2 = 5;
            } else if("√^".indexOf(tipcommand2) != -1) {
                tiptype2 = 6;
            } else if("sincostanloglnn!".indexOf(tipcommand2) != -1) {
                tiptype2 = 7;
            }
            
            switch(tiptype1) {
            case 1:
            //左括号后面直接接右括号,“ x÷”(负号“-”不算),或者"√^"
                if(tiptype2 == 2 || (tiptype2 == 5 && tipcommand2.compareTo("-") != 0) || 
                        tiptype2 == 6) 
                    Tipcode1 = 1;
                break;
            case 2:
            //右括号后面接左括号,数字,“ -x÷sin^...”
                if(tiptype2 == 1 || tiptype2 == 3 || tiptype2 == 4 || tiptype2 == 7)
                Tipcode1 = 2;
                break;
            case 3:
            //“.”后面接左括号或者“sincos...”
                if(tiptype2 == 1 || tiptype2 == 7)
                Tipcode1 = 3;
                //连续输入两个“.”
                if(tiptype2 == 3)
                Tipcode1 = 8;
                break;            
            case 4:
            //数字后面直接接左括号或者“sincos...”
                if(tiptype2 == 1 || tiptype2 == 7)
                Tipcode1 = 4;
                break;
            case 5:
            //“ -x÷”后面直接接右括号,“ -x÷√^”
                if(tiptype2 == 2 || tiptype2 == 5 || tiptype2 == 6)
                Tipcode1 = 5;
                break;
            case 6:
            //“√^”后面直接接右括号,“ -x÷√^”以及“sincos...”
                if(tiptype2 == 2 || tiptype2 == 5 || tiptype2 == 6 || tiptype2 == 7)
                Tipcode1 = 6;
                break;
            case 7:
            //“sincos...”后面直接接右括号“ -x÷√^”以及“sincos...”
                if(tiptype2 == 2 || tiptype2 == 5 || tiptype2 == 6 || tiptype2 == 7)
                Tipcode1 = 7;
                break;
            }
        }
        //检测小数点的重复性,Tipconde1=0,表明满足前面的规则
        if(Tipcode1 == 0 && tipcommand2.compareTo(".") == 0) {
            int tip_point = 0;
            for(int i = 0;i < tip_i;i ) {
            //若之前出现一个小数点点,则小数点计数加1
                if(Tipcommand[i].compareTo(".") == 0) {
                    tip_point ;
                }
                //若出现以下几个运算符之一,小数点计数清零
                if(Tipcommand[i].compareTo("sin") == 0 || Tipcommand[i].compareTo("cos") == 0 ||
                        Tipcommand[i].compareTo("tan") == 0 || Tipcommand[i].compareTo("log") == 0 ||
                        Tipcommand[i].compareTo("ln") == 0 || Tipcommand[i].compareTo("n!") == 0 || 
                        Tipcommand[i].compareTo("√") == 0 || Tipcommand[i].compareTo("^") == 0 || 
                        Tipcommand[i].compareTo("÷") == 0 || Tipcommand[i].compareTo("×") == 0 || 
                        Tipcommand[i].compareTo("-") == 0 || Tipcommand[i].compareTo(" ") == 0 || 
                        Tipcommand[i].compareTo("(") == 0 || Tipcommand[i].compareTo(")") == 0 ) {
                    tip_point = 0;
                }
            }
            tip_point ;
            //若小数点计数大于1,表明小数点重复了
            if(tip_point > 1) {
                Tipcode1 = 8;
            }
        }
        //检测右括号是否匹配
        if(Tipcode1 == 0 && tipcommand2.compareTo(")") == 0) {
            int tip_right_bracket = 0;
            for(int i = 0;i < tip_i;i ) {
            //如果出现一个左括号,则计数加1
                if(Tipcommand[i].compareTo("(") == 0) {
                    tip_right_bracket ;
                }
                //如果出现一个右括号,则计数减1
                if(Tipcommand[i].compareTo(")") == 0) {
                    tip_right_bracket--;
                }
            }
            //如果右括号计数=0,表明没有响应的左括号与当前右括号匹配
            if(tip_right_bracket == 0) {
                Tipcode1 = 10; 
            }
        }
        //检查输入=的合法性
        if(Tipcode1 == 0 && tipcommand2.compareTo("=") == 0) {
        //括号匹配数
        int tip_bracket = 0; 
            for(int i = 0;i < tip_i;i ) {
                if(Tipcommand[i].compareTo("(") == 0) {
                    tip_bracket ;
                }
                if(Tipcommand[i].compareTo(")") == 0) {
                    tip_bracket--;
                }
            }
            //若大于0,表明左括号还有未匹配的
            if(tip_bracket > 0) {
                Tipcode1 = 9; 
                bracket = tip_bracket;
            } else if(tip_bracket == 0) {
            //若前一个字符是以下之一,表明=号不合法
                if("√^sincostanloglnn!".indexOf(tipcommand1) != -1) {
                    Tipcode1 = 6;
                }
                //若前一个字符是以下之一,表明=号不合法
                if(" -×÷".indexOf(tipcommand1) != -1) {
                    Tipcode1 = 5;
                }
            }
        }
        //若命令式以下之一,则显示相应的帮助信息
        if(tipcommand2.compareTo("MC") == 0) Tipcode2 = 1;
        if(tipcommand2.compareTo("C") == 0) Tipcode2 = 2;
        if(tipcommand2.compareTo("DRG") == 0) Tipcode2 = 3;
        if(tipcommand2.compareTo("Bksp") == 0) Tipcode2 = 4;
        if(tipcommand2.compareTo("sin") == 0) Tipcode2 = 5;
        if(tipcommand2.compareTo("cos") == 0) Tipcode2 = 6;
        if(tipcommand2.compareTo("tan") == 0) Tipcode2 = 7;
        if(tipcommand2.compareTo("log") ==0) Tipcode2 = 8;
        if(tipcommand2.compareTo("ln") == 0) Tipcode2 = 9;
        if(tipcommand2.compareTo("n!") == 0) Tipcode2 = 10;
        if(tipcommand2.compareTo("√") == 0) Tipcode2 = 11;
        if(tipcommand2.compareTo("^") == 0) Tipcode2 = 12;
        //显示帮助和错误信息
        TipShow(bracket , Tipcode1 , Tipcode2 , tipcommand1 , tipcommand2);
    }
    
    /*
     * 反馈Tip信息,加强人机交互,与TipChecker()配合使用
     */
    private void TipShow(int bracket , int tipcode1 , int tipcode2 , 
            String tipcommand1 , String tipcommand2) {
        String tipmessage = "";
        if(tipcode1 != 0) 
        tip_lock = false;//表明输入有误
        switch(tipcode1) {
        case -1:
            tipmessage = tipcommand2 "  不能作为第一个算符\n";
            break;
        case 1:
            tipmessage = tipcommand1 "  后应输入:数字/(/./-/函数 \n";
            break;
        case 2:
            tipmessage = tipcommand1 "  后应输入:)/算符 \n";
            break;
        case 3:
            tipmessage = tipcommand1 "  后应输入:)/数字/算符 \n";
            break;
        case 4:
            tipmessage = tipcommand1 "  后应输入:)/./数字 /算符 \n";
            break;
        case 5:
            tipmessage = tipcommand1 "  后应输入:(/./数字/函数 \n";
            break;
        case 6:
            tipmessage = tipcommand1 "  后应输入:(/./数字 \n";
            break;
        case 7:
            tipmessage = tipcommand1 "  后应输入:(/./数字 \n";
            break;
        case 8:
            tipmessage = "小数点重复\n";
            break;
        case 9:
            tipmessage = "不能计算,缺少 " bracket " 个 )";
            break;
        case 10:
            tipmessage = "不需要  )";
            break;
        }        
        switch(tipcode2) {
        case 1:
            tipmessage = tipmessage "[MC 用法: 清除记忆 MEM]";
            break;
        case 2:
            tipmessage = tipmessage "[C 用法: 归零]";
            break;
        case 3:
            tipmessage = tipmessage "[DRG 用法: 选择 DEG 或 RAD]";
            break;
        case 4:
            tipmessage = tipmessage "[Bksp 用法: 退格]";
            break;
        case 5:
            tipmessage = tipmessage "sin 函数用法示例:\n"
                    "DEG:sin30 = 0.5      RAD:sin1 = 0.84\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "sin(cos45),而不是sincos45" ;
            break;
        case 6:
            tipmessage = tipmessage "cos 函数用法示例:\n"
                    "DEG:cos60 = 0.5      RAD:cos1 = 0.54\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "cos(sin45),而不是cossin45" ;
            break;
        case 7:
            tipmessage = tipmessage "tan 函数用法示例:\n"
                    "DEG:tan45 = 1      RAD:tan1 = 1.55\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "tan(cos45),而不是tancos45" ;
            break;
        case 8:
            tipmessage = tipmessage "log 函数用法示例:\n"
                    "log10 = log(5 5) = 1\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "log(tan45),而不是logtan45" ;
            break;
        case 9:
            tipmessage = tipmessage "ln 函数用法示例:\n"
                    "ln10 = le(5 5) = 2.3   lne = 1\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "ln(tan45),而不是lntan45" ;
            break;
        case 10:
            tipmessage = tipmessage "n! 函数用法示例:\n"
                    "n!3 = n!(1 2) = 3×2×1 = 6\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "n!(log1000),而不是n!log1000" ;
            break;
        case 11:
            tipmessage = tipmessage "√ 用法示例:开任意次根号\n"
                    "如:27开3次根为  27√3 = 3\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "(函数)√(函数) , (n!3)√(log100) = 2.45";
            break;
        case 12:
            tipmessage = tipmessage "^ 用法示例:开任意次平方\n"
                    "如:2的3次方为  2^3 = 8\n"
                    "注:与其他函数一起使用时要加括号,如:\n"
                    "(函数)√(函数) , (n!3)^(log100) = 36";
            break;
        }
        //将提示信息显示到tip
        tip.setText(tipmessage);
    }
    /*
     * 整个计算核心,只要将表达式的整个字符串传入calc().process()就可以实行计算了
     * 算法包括以下几部分:
     * 1、计算部分           process(String str)  当然,这是建立在查错无错误的情况下
     * 2、数据格式化      FP(double n)         使数据有相当的精确度
     * 3、阶乘算法           N(double n)          计算n!,将结果返回
     * 4、错误提示          showError(int code ,String str)  将错误返回
     */
    public class calc {
         public calc(){
             
        }
         final int MAXLEN = 500;
            /* 
             * 计算表达式
             * 从左向右扫描,数字入number栈,运算符入operator栈
             * -基本优先级为1,×÷基本优先级为2,log ln sin cos tan n!基本优先级为3,√^基本优先级为4
             * 括号内层运算符比外层同级运算符优先级高4
             * 当前运算符优先级高于栈顶压栈,低于栈顶弹出一个运算符与两个数进行运算
             * 重复直到当前运算符大于栈顶
             * 扫描完后对剩下的运算符与数字依次计算
             */
            public void process(String str) {
                int weightPlus = 0, topOp = 0,
                topNum = 0, flag = 1, weightTemp = 0;
                //weightPlus为同一()下的基本优先级,weightTemp临时记录优先级的变化
                //topOp为weight[],operator[]的计数器;topNum为number[]的计数器
                //flag为正负数的计数器,1为正数,-1为负数
                int weight[];  //保存operator栈中运算符的优先级,以topOp计数
                double number[];  //保存数字,以topNum计数
                char ch, ch_gai, operator[];//operator[]保存运算符,以topOp计数
                String num;//记录数字,str以 -×÷()sctgl!√^分段, -×÷()sctgl!√^字符之间的字符串即为数字
                weight = new int[MAXLEN];
                number = new double[MAXLEN];
                operator = new char[MAXLEN];
                String expression = str;
                StringTokenizer expToken = new StringTokenizer(expression," -×÷()sctgl!√^");
                int i = 0;
                while (i < expression.length()) {
                    ch = expression.charAt(i);
                    //判断正负数
                    if (i == 0) {
                        if (ch == '-')
                        flag = -1;
                    } else if(expression.charAt(i-1) == '(' && ch == '-')
                    flag = -1;
                    //取得数字,并将正负符号转移给数字
                    if (ch <= '9' && ch >= '0'|| ch == '.' || ch == 'E') {
                        num = expToken.nextToken();
                        ch_gai = ch;
                        Log.e("guojs",ch "--->" i);
                        //取得整个数字
                        while (i < expression.length() && 
                                (ch_gai <= '9' && ch_gai >= '0'|| ch_gai == '.' || ch_gai == 'E')) 
                        {
                            ch_gai = expression.charAt(i );
                            Log.e("guojs","i的值为:" i);
                        }
                        //将指针退回之前的位置
                        if (i >= expression.length()) i-=1; else {i-=2;}
                        if (num.compareTo(".") == 0) number[topNum ] = 0;
                        //将正负符号转移给数字
                        else {
                            number[topNum ] = Double.parseDouble(num)*flag;
                            flag = 1;
                        }
                    }
                    //计算运算符的优先级
                    if (ch == '(') weightPlus =4;
                    if (ch == ')') weightPlus-=4;
                    if (ch == '-' && flag == 1 || ch == ' ' || ch == '×'|| ch == '÷' || 
                            ch == 's' ||ch == 'c' || ch == 't' || ch == 'g' || ch == 'l' || 
                            ch == '!' || ch == '√' || ch == '^') {
                        switch (ch) {
                        // -的优先级最低,为1
                            case ' ':
                            case '-':
                                weightTemp = 1 weightPlus;
                                break;
                            //x÷的优先级稍高,为2
                            case '×':
                            case '÷':
                                weightTemp = 2 weightPlus;
                                break;
                            //sincos之类优先级为3
                            case 's':
                            case 'c':
                            case 't':
                            case 'g':
                            case 'l':
                            case '!':
                                weightTemp = 3 weightPlus;
                                break;
                            //其余优先级为4
                            //case '^':
                            //case '√':
                            default:
                                weightTemp = 4 weightPlus;
                                break;
                        }
                        //如果当前优先级大于堆栈顶部元素,则直接入栈
                        if (topOp == 0 || weight[topOp-1] < weightTemp) {
                            weight[topOp] = weightTemp;
                            operator[topOp] = ch;
                            topOp ;
                        //否则将堆栈中运算符逐个取出,直到当前堆栈顶部运算符的优先级小于当前运算符
                        }else {
                             while (topOp > 0 && weight[topOp-1] >= weightTemp) {
                                switch (operator[topOp-1]) {
                                //取出数字数组的相应元素进行运算
                                    case ' ':
                                        number[topNum-2] =number[topNum-1];
                                        break;
                                    case '-':
                                        number[topNum-2]-=number[topNum-1];
                                        break;
                                    case '×':
                                        number[topNum-2]*=number[topNum-1];
                                        break;
                                    //判断除数为0的情况
                                    case '÷':
                                        if (number[topNum-1] == 0) {
                                            showError(1,str_old);
                                            return;
                                        }
                                        number[topNum-2]/=number[topNum-1];
                                        break;
                                    case '√':
                                        if(number[topNum-1] == 0 || (number[topNum-2] < 0 &&
                                                number[topNum-1] % 2 == 0)) {
                                            showError(2,str_old);
                                            return;    
                                        } 
                                        number[topNum-2] = 
                                            Math.pow(number[topNum-2], 1/number[topNum-1]);
                                        break;
                                    case '^':
                                        number[topNum-2] = 
                                            Math.pow(number[topNum-2], number[topNum-1]);
                                        break;
                                    //计算时进行角度弧度的判断及转换
                                    //sin
                                    case 's':
                                        if(drg_flag == true) {
                                            number[topNum-1] = Math.sin((number[topNum-1]/180)*pi);
                                        } else {
                                            number[topNum-1] = Math.sin(number[topNum-1]);
                                        }
                                        topNum ;
                                        break;
                                    //cos
                                    case 'c':
                                        if(drg_flag == true) {
                                            number[topNum-1] = Math.cos((number[topNum-1]/180)*pi);
                                        } else {
                                            number[topNum-1] = Math.cos(number[topNum-1]);
                                        }
                                        topNum ;
                                        break;
                                    //tan
                                    case 't':
                                        if(drg_flag == true) {
                                            if((Math.abs(number[topNum-1])/90)%2 == 1) {
                                                showError(2,str_old);
                                                return;
                                            }
                                            number[topNum-1] = Math.tan((number[topNum-1]/180)*pi);
                                        } else {
                                            if((Math.abs(number[topNum-1])/(pi/2))%2 == 1) {
                                                showError(2,str_old);
                                                return;
                                            }
                                            number[topNum-1] = Math.tan(number[topNum-1]);
                                        }
                                        topNum ;
                                        break;
                                    //log
                                    case 'g':
                                        if(number[topNum-1] <= 0) {
                                            showError(2,str_old);
                                            return;    
                                        } 
                                        number[topNum-1] = Math.log10(number[topNum-1]);
                                        topNum ;
                                        break;
                                    //ln
                                    case 'l':
                                        if(number[topNum-1] <= 0) {
                                            showError(2,str_old);
                                            return;    
                                        } 
                                        number[topNum-1] = Math.log(number[topNum-1]);
                                        topNum ;
                                        break;
                                    //阶乘
                                    case '!':
                                        if(number[topNum-1] > 170) {
                                            showError(3,str_old);
                                            return;    
                                        } else if(number[topNum-1] < 0) {
                                            showError(2,str_old);
                                            return;
                                        }
                                        number[topNum-1] = N(number[topNum-1]);
                                        topNum ;
                                        break;
                                }
                                //继续取堆栈的下一个元素进行判断
                                topNum--;
                                topOp--;
                            }
                            //将运算符如堆栈
                            weight[topOp] = weightTemp;
                            operator[topOp] = ch;
                            topOp ;
                        }
                    }
                    i ;
                }
                //依次取出堆栈的运算符进行运算
                while (topOp>0) {
                // -x直接将数组的后两位数取出运算
                    switch (operator[topOp-1]) {
                    case ' ':
                        number[topNum-2] =number[topNum-1];
                        break;
                    case '-':
                        number[topNum-2]-=number[topNum-1];
                        break;
                    case '×':
                        number[topNum-2]*=number[topNum-1];
                        break;
                    //涉及到除法时要考虑除数不能为零的情况
                    case '÷':
                        if (number[topNum-1] == 0) {
                            showError(1,str_old);
                            return;
                        }
                        number[topNum-2]/=number[topNum-1];
                        break;
                    case '√':
                        if(number[topNum-1] == 0 || (number[topNum-2] < 0 &&
                                number[topNum-1] % 2 == 0)) {
                            showError(2,str_old);
                            return;    
                        } 
                        number[topNum-2] = 
                            Math.pow(number[topNum-2], 1/number[topNum-1]);
                        break;
                    case '^':
                        number[topNum-2] = 
                            Math.pow(number[topNum-2], number[topNum-1]);
                        break;
                    //sin
                    case 's':
                        if(drg_flag == true) {
                            number[topNum-1] = Math.sin((number[topNum-1]/180)*pi);
                        } else {
                            number[topNum-1] = Math.sin(number[topNum-1]);
                        }
                        topNum ;
                        break;
                    //cos
                    case 'c':
                        if(drg_flag == true) {
                            number[topNum-1] = Math.cos((number[topNum-1]/180)*pi);
                        } else {
                            number[topNum-1] = Math.cos(number[topNum-1]);
                        }
                        topNum ;
                        break;
                    //tan
                    case 't':
                        if(drg_flag == true) {
                            if((Math.abs(number[topNum-1])/90)%2 == 1) {
                                showError(2,str_old);
                                return;
                            }
                            number[topNum-1] = Math.tan((number[topNum-1]/180)*pi);
                        } else {
                            if((Math.abs(number[topNum-1])/(pi/2))%2 == 1) {
                                showError(2,str_old);
                                return;
                            }
                            number[topNum-1] = Math.tan(number[topNum-1]);
                        }
                        topNum ;
                        break;
                    //对数log
                    case 'g':
                        if(number[topNum-1] <= 0) {
                            showError(2,str_old);
                            return;    
                        } 
                        number[topNum-1] = Math.log10(number[topNum-1]);
                        topNum ;
                        break;
                    //自然对数ln
                    case 'l':
                        if(number[topNum-1] <= 0) {
                            showError(2,str_old);
                            return;    
                        } 
                        number[topNum-1] = Math.log(number[topNum-1]);
                        topNum ;
                        break;
                    //阶乘
                    case '!':
                        if(number[topNum-1] > 170) {
                            showError(3,str_old);
                            return;    
                        } else if(number[topNum-1] < 0) {
                            showError(2,str_old);
                            return;
                        }
                        number[topNum-1] = N(number[topNum-1]);
                        topNum ;
                        break;
                    }
                    //取堆栈下一个元素计算
                    topNum--;
                    topOp--;
                }
                //如果是数字太大,提示错误信息
                if(number[0] > 7.3E306) {
                    showError(3,str_old);
                    return;
                }
                //输出最终结果
                input.setText(String.valueOf(FP(number[0]))); 
                tip.setText("计算完毕,要继续请按归零键 C");
                mem.setText(str_old "=" String.valueOf(FP(number[0])));
            }
            
            /*
             * FP = floating point 控制小数位数,达到精度
             * 否则会出现 0.6-0.2=0.39999999999999997的情况,用FP即可解决,使得数为0.4
             * 本格式精度为15位
             */
            public double FP(double n) {
                //NumberFormat format=NumberFormat.getInstance();  //创建一个格式化类f
                //format.setMaximumFractionDigits(18);    //设置小数位的格式
                DecimalFormat format = new DecimalFormat("0.#############");
                return Double.parseDouble(format.format(n));
            }
            
            /*
             * 阶乘算法
             */
            public double N(double n) { 
                int i = 0;
                double sum = 1;
                //依次将小于等于n的值相乘
                for(i = 1;i <= n;i ) {
                    sum = sum*i;
                }
                return sum;
            }
            
            /*
             * 错误提示,按了"="之后,若计算式在process()过程中,出现错误,则进行提示
             */
            public void showError(int code ,String str) {
                String message="";
                switch (code) {
                case 1:
                    message = "零不能作除数";
                    break;
                case 2:
                    message = "函数格式错误";
                    break;
                case 3:
                    message = "值太大了,超出范围";
                }
                input.setText("\"" str "\"" ": " message);
                tip.setText(message "\n" "计算完毕,要继续请按归零键 C");
            }  
        }
}

标签: 计算器 计算

实例下载地址

android 计算器源码(计算,三角,函数,记忆)

不能下载?内容有错? 点击这里报错 + 投诉 + 提问

好例子网口号:伸出你的我的手 — 分享

网友评论

发表评论

(您的评论需要经过审核才能显示)

查看所有0条评论>>

小贴士

感谢您为本站写下的评论,您的评论对其它用户来说具有重要的参考价值,所以请认真填写。

  • 类似“顶”、“沙发”之类没有营养的文字,对勤劳贡献的楼主来说是令人沮丧的反馈信息。
  • 相信您也不想看到一排文字/表情墙,所以请不要反馈意义不大的重复字符,也请尽量不要纯表情的回复。
  • 提问之前请再仔细看一遍楼主的说明,或许是您遗漏了。
  • 请勿到处挖坑绊人、招贴广告。既占空间让人厌烦,又没人会搭理,于人于己都无利。

关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享,对搜索内容的合法性不具有预见性、识别性、控制性,仅供学习研究,请务必在下载后24小时内给予删除,不得用于其他任何用途,否则后果自负。基于互联网的特殊性,平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查;无论平台是否已进行审查,用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场,基于网友分享,根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定,若资源存在侵权或相关问题请联系本站客服人员,点此联系我们。关于更多版权及免责申明参见 版权及免责申明

;
报警