andriod 带看括弧的计算器

界面

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="#ff808080"
    >
    <!-- 结果显示框 -->
    <EditText android:id="@+id/input"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:cursorVisible="false"
        android:gravity="right"
        android:editable = "false"
        android:text="0"                               />
    <!-- 接下去采TableRow的格式进行布局设计 -->
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 用于显示存储结果 -->
        <TextView android:id="@+id/M"
            android:layout_width="53sp"
            android:layout_height="wrap_content"
            android:text="  MEM :"                 />
        <!-- 默认显示字符串0 -->
        <TextView android:id="@+id/mem"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="0"                       />
    </TableRow>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 显示当前是角度还是弧度，默认是角度 -->
        <TextView android:id="@+id/_drg"
            android:layout_width="53sp"
            android:layout_height="wrap_content"
            android:text="   DEG"                 />
        <!-- 清除存储结果 -->
        <Button android:id="@+id/mc"
            android:text="MC"
            android:layout_width="106sp"
            android:layout_height="wrap_content"   />
        <!-- 清除输出窗口的所有内容 -->
        <Button android:id="@+id/c"
            android:text="C"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"   />
    </TableRow>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 在角度和弧度之间切换 -->
        <Button android:id="@+id/drg"
            android:text="DRG"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 正弦计算 -->
        <Button android:id="@+id/sin"
            android:text="sin"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 余弦计算 -->
        <Button android:id="@+id/cos"
            android:text="cos"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 正切计算 -->
        <Button android:id="@+id/tan"
            android:text="tan"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 阶乘计算 -->
        <Button android:id="@+id/factorial"
            android:text="n!"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 退格键 -->
        <Button android:id="@+id/bksp"
            android:text="Bksp"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
    </TableRow>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 数字7 -->
        <Button android:id="@+id/seven"
            android:text="7"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字8 -->
        <Button android:id="@+id/eight"
            android:text="8"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字9 -->
        <Button android:id="@+id/nine"
            android:text="9"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 除号 -->
        <Button android:id="@+id/divide"
            android:text="÷"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 左括号 -->
        <Button android:id="@+id/left"
            android:text="("
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 右括号 -->
        <Button android:id="@+id/right"
            android:text=")"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
    </TableRow>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 数字4 -->
        <Button android:id="@+id/four"
            android:text="4"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字5 -->
        <Button android:id="@+id/five"
            android:text="5"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字6 -->
        <Button android:id="@+id/six"
            android:text="6"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 乘号 -->
        <Button android:id="@+id/mul"
            android:text="×"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 开方 -->
        <Button android:id="@+id/sqrt"
            android:text="√"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 乘方 -->
        <Button android:id="@+id/square"
            android:text="^"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
    </TableRow>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 数字1 -->
        <Button android:id="@+id/one"
            android:text="1"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字2 -->
        <Button android:id="@+id/two"
            android:text="2"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 数字3 -->
        <Button android:id="@+id/three"
            android:text="3"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 减号 -->
        <Button android:id="@+id/sub"
            android:text="-"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 对数 -->
        <Button android:id="@+id/log"
            android:text="log"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
        <!-- 自然对数 -->
        <Button android:id="@+id/ln"
            android:text="ln"
            android:layout_width="53sp"
            android:layout_height="wrap_content" />
    </TableRow>
    <TableLayout
        android:layout_width="fill_parent"
        android:layout_height="57sp"
        >
        <TableRow
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            >
            <!-- 数字0 -->
            <Button android:id="@+id/zero"
                android:text="0"
                android:layout_width="53sp"
                android:layout_height="wrap_content" />
            <!-- 小数点 -->
            <Button android:id="@+id/dot"
                android:text="."
                android:layout_width="53sp"
                android:layout_height="wrap_content" />
            <!-- 等号 -->
            <Button android:id="@+id/equal"
                android:text="="
                android:layout_width="53sp"
                android:layout_height="wrap_content" />
            <!-- 加号 -->
            <Button android:id="@+id/add"
                android:text="+"
                android:layout_width="53sp"
                android:layout_height="wrap_content" />
            <!-- 退出计算器 -->
            <Button android:id="@+id/exit"
                android:text="exit"
                android:layout_width="106sp"
                android:layout_height="wrap_content" />
        </TableRow>
    </TableLayout>
    <TableRow
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        >
        <!-- 用于提示，告诉用户如何使用计算器的一些功能等 -->
        <TextView android:id="@+id/T"
            android:layout_width="60sp"
            android:layout_height="wrap_content"
            android:text="reminder:"                 />
        <TextView android:id="@+id/tip"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="欢迎使用！-www.javaapk.com 提供源码"                 />
    </TableRow>
</LinearLayout>

代码

package com.example.yanlei.mytk;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.Spinner;

import java.util.ArrayList;
import java.util.List;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.Gallery;
import android.widget.Gallery.LayoutParams;
import android.widget.ImageSwitcher;
import android.widget.ImageView;
import android.widget.ViewSwitcher;
import java.text.DecimalFormat;
import java.util.StringTokenizer;

import android.os.Bundle;

import android.R.integer;
import android.app.Activity;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;



public class MainActivity extends AppCompatActivity  {


    // 定义变量
    private Button[] btn = new Button[10];// 0~9十个数字
    private EditText input;// 用于显示输出结果
    private TextView mem, _drg, tip;
    private Button div, mul, sub, add, equal, sin, cos, tan, log, ln, sqrt,
            square, factorial, bksp, left, right, dot, exit, drg, mc, c;
    public String str_old;
    public String str_new;
    public boolean vbegin = true;// 控制输入，true为重新输入，false为接着输入
    public boolean drg_flag = true;// true为角度，false为弧度
    public double pi = 4 * Math.atan(1);// π值
    public boolean tip_lock = true;// true为正确，可以继续输入，false错误，输入锁定
    public boolean equals_flag = true;// 是否在按下=之后输入，true为之前，false为之后

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        InitWigdet();
        AllWigdetListener();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    /**
     * 初始化所有的组件
     */
    private void InitWigdet() {
        // 获取界面元素
        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);
    }

    /**
     * 为所有按键绑定监听器
     */
    private void AllWigdetListener() {
        // 数字键
        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];
    int tip_i = 0;// TipCommand的指针
    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("welcome use the APP！");
                }

                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("welcome use the APP！");
                    }
                    // 依次删除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("welcome use the APP！");
                    }
                    // 依次删除一个字符
                } 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("welcome use the APP！");
                        }
                        // 若之前输入的字符串不合法则删除全部字符
                    } else {
                        input.setText("0");
                        vbegin = true;
                        tip_i = 0;
                        tip.setText("welcome use the APP！");
                    }
                }
                if (input.getText().toString().compareTo("-") == 0
                        || equals_flag == false) {
                    input.setText("0");
                    vbegin = true;
                    tip_i = 0;
                    tip.setText("welcome use the APP！");
                }
                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("welcome use the APP！");
                // 如果输入的是清除键
            } 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("welcome use the APP！");
                // 如果输入的是”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;
        }

    };

    /*
     * 检测函数，对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 + "  不能作为第一个算符
";
                break;
            case 1:
                tipmessage = tipcommand1 + "  后应输入：数字/(/./-/函数 
";
                break;
            case 2:
                tipmessage = tipcommand1 + "  后应输入：)/算符 
";
                break;
            case 3:
                tipmessage = tipcommand1 + "  后应输入：)/数字/算符 
";
                break;
            case 4:
                tipmessage = tipcommand1 + "  后应输入：)/./数字 /算符 
";
                break;
            case 5:
                tipmessage = tipcommand1 + "  后应输入：(/./数字/函数 
";
                break;
            case 6:
                tipmessage = tipcommand1 + "  后应输入：(/./数字 
";
                break;
            case 7:
                tipmessage = tipcommand1 + "  后应输入：(/./数字 
";
                break;
            case 8:
                tipmessage = "小数点重复
";
                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 函数用法示例：
"
                        + "DEG：sin30 = 0.5      RAD：sin1 = 0.84
"
                        + "注：与其他函数一起使用时要加括号，如：
" + "sin(cos45)，而不是sincos45";
                break;
            case 6:
                tipmessage = tipmessage + "cos 函数用法示例：
"
                        + "DEG：cos60 = 0.5      RAD：cos1 = 0.54
"
                        + "注：与其他函数一起使用时要加括号，如：
" + "cos(sin45)，而不是cossin45";
                break;
            case 7:
                tipmessage = tipmessage + "tan 函数用法示例：
"
                        + "DEG：tan45 = 1      RAD：tan1 = 1.55
"
                        + "注：与其他函数一起使用时要加括号，如：
" + "tan(cos45)，而不是tancos45";
                break;
            case 8:
                tipmessage = tipmessage + "log 函数用法示例：
"
                        + "log10 = log(5+5) = 1
" + "注：与其他函数一起使用时要加括号，如：
"
                        + "log(tan45)，而不是logtan45";
                break;
            case 9:
                tipmessage = tipmessage + "ln 函数用法示例：
"
                        + "ln10 = le(5+5) = 2.3   lne = 1
"
                        + "注：与其他函数一起使用时要加括号，如：
" + "ln(tan45)，而不是lntan45";
                break;
            case 10:
                tipmessage = tipmessage + "n! 函数用法示例：
"
                        + "n!3 = n!(1+2) = 3×2×1 = 6
" + "注：与其他函数一起使用时要加括号，如：
"
                        + "n!(log1000)，而不是n!log1000";
                break;
            case 11:
                tipmessage = tipmessage + "√ 用法示例：开任意次根号
"
                        + "如：27开3次根为  27√3 = 3
" + "注：与其他函数一起使用时要加括号，如：
"
                        + "(函数)√(函数) ， (n!3)√(log100) = 2.45";
                break;
            case 12:
                tipmessage = tipmessage + "^ 用法示例：开任意次平方
" + "如：2的3次方为  2^3 = 8
"
                        + "注：与其他函数一起使用时要加括号，如：
"
                        + "(函数)√(函数) ， (n!3)^(log100) = 36";
                break;
        }
        // 将提示信息显示到tip
        tip.setText(tipmessage);

    }

    /**
     * 将信息显示在显示屏上
     */
    private void print(String str) {
        // 清屏后输出
        if (vbegin) {
            input.setText(str);
        } else {
            input.append(str);
        }
        vbegin = 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是否是合法的，返回值为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;
        }
    }

    /*
     * 整个计算核心，
     * 只要将表达式的整个字符串传入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 + "
" + "计算完毕，要继续请按归零键 C");
        }
    }

}

菜单menu_main.xml

<menu xmlns:android="http://schemas.android.com/apk/res/android" >

    <item
        android:id="@+id/action_settings"
        android:orderInCategory="100"
        android:showAsAction="never"
        android:title="@string/action_settings"/>

</menu>