Java implementiert Android-Rechnercode mit Klammern

Kein Unsinn mehr, alles ist im Code enthalten:

Schnittstelle

<?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>

Menü menu_main xml

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 + " 不能作为第一个算符\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);
}
/**
* 将信息显示在显示屏上
*/
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) == &#39;n&#39;
&& str.charAt(str.length() - 2) == &#39;i&#39; && str.charAt(str
.length() - 3) == &#39;s&#39;)
|| (str.charAt(str.length() - 1) == &#39;s&#39;
&& str.charAt(str.length() - 2) == &#39;o&#39; && str
.charAt(str.length() - 3) == &#39;c&#39;)
|| (str.charAt(str.length() - 1) == &#39;n&#39;
&& str.charAt(str.length() - 2) == &#39;a&#39; && str
.charAt(str.length() - 3) == &#39;t&#39;)
|| (str.charAt(str.length() - 1) == &#39;g&#39;
&& str.charAt(str.length() - 2) == &#39;o&#39; && str
.charAt(str.length() - 3) == &#39;l&#39;)) {
return 3;
} else if ((str.charAt(str.length() - 1) == &#39;n&#39; && str.charAt(str
.length() - 2) == &#39;l&#39;)
|| (str.charAt(str.length() - 1) == &#39;!&#39; && str.charAt(str
.length() - 2) == &#39;n&#39;)) {
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) != &#39;0&#39; && str.charAt(i) != &#39;1&#39;
&& str.charAt(i) != &#39;2&#39; && str.charAt(i) != &#39;3&#39;
&& str.charAt(i) != &#39;4&#39; && str.charAt(i) != &#39;5&#39;
&& str.charAt(i) != &#39;6&#39; && str.charAt(i) != &#39;7&#39;
&& str.charAt(i) != &#39;8&#39; && str.charAt(i) != &#39;9&#39;
&& str.charAt(i) != &#39;.&#39; && str.charAt(i) != &#39;-&#39;
&& str.charAt(i) != &#39;+&#39; && str.charAt(i) != &#39;×&#39;
&& str.charAt(i) != &#39;÷&#39; && str.charAt(i) != &#39;√&#39;
&& str.charAt(i) != &#39;^&#39; && str.charAt(i) != &#39;s&#39;
&& str.charAt(i) != &#39;i&#39; && str.charAt(i) != &#39;n&#39;
&& str.charAt(i) != &#39;c&#39; && str.charAt(i) != &#39;o&#39;
&& str.charAt(i) != &#39;t&#39; && str.charAt(i) != &#39;a&#39;
&& str.charAt(i) != &#39;l&#39; && str.charAt(i) != &#39;g&#39;
&& str.charAt(i) != &#39;(&#39; && str.charAt(i) != &#39;)&#39;
&& str.charAt(i) != &#39;!&#39;)
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 == &#39;-&#39;)
flag = -1;
} else if (expression.charAt(i - 1) == &#39;(&#39; && ch == &#39;-&#39;)
flag = -1;
// 取得数字，并将正负符号转移给数字
if (ch <= &#39;9&#39; && ch >= &#39;0&#39; || ch == &#39;.&#39; || ch == &#39;E&#39;) {
num = expToken.nextToken();
ch_gai = ch;
Log.e("guojs", ch + "--->" + i);
// 取得整个数字
while (i < expression.length()
&& (ch_gai <= &#39;9&#39; && ch_gai >= &#39;0&#39; || ch_gai == &#39;.&#39; || ch_gai == &#39;E&#39;)) {
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 == &#39;(&#39;)
weightPlus += 4;
if (ch == &#39;)&#39;)
weightPlus -= 4;
if (ch == &#39;-&#39; && flag == 1 || ch == &#39;+&#39; || ch == &#39;×&#39;
|| ch == &#39;÷&#39; || ch == &#39;s&#39; || ch == &#39;c&#39; || ch == &#39;t&#39;
|| ch == &#39;g&#39; || ch == &#39;l&#39; || ch == &#39;!&#39; || ch == &#39;√&#39;
|| ch == &#39;^&#39;) {
switch (ch) {
// +-的优先级最低，为1
case &#39;+&#39;:
case &#39;-&#39;:
weightTemp = 1 + weightPlus;
break;
// x÷的优先级稍高，为2
case &#39;×&#39;:
case &#39;÷&#39;:
weightTemp = 2 + weightPlus;
break;
// sincos之类优先级为3
case &#39;s&#39;:
case &#39;c&#39;:
case &#39;t&#39;:
case &#39;g&#39;:
case &#39;l&#39;:
case &#39;!&#39;:
weightTemp = 3 + weightPlus;
break;
// 其余优先级为4
// case &#39;^&#39;:
// case &#39;√&#39;:
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 &#39;+&#39;:
number[topNum - 2] += number[topNum - 1];
break;
case &#39;-&#39;:
number[topNum - 2] -= number[topNum - 1];
break;
case &#39;×&#39;:
number[topNum - 2] *= number[topNum - 1];
break;
// 判断除数为0的情况
case &#39;÷&#39;:
if (number[topNum - 1] == 0) {
showError(1, str_old);
return;
}
number[topNum - 2] /= number[topNum - 1];
break;
case &#39;√&#39;:
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 &#39;^&#39;:
number[topNum - 2] = Math.pow(
number[topNum - 2], number[topNum - 1]);
break;
// 计算时进行角度弧度的判断及转换
// sin
case &#39;s&#39;:
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 &#39;c&#39;:
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 &#39;t&#39;:
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 &#39;g&#39;:
if (number[topNum - 1] <= 0) {
showError(2, str_old);
return;
}
number[topNum - 1] = Math
.log10(number[topNum - 1]);
topNum++;
break;
// ln
case &#39;l&#39;:
if (number[topNum - 1] <= 0) {
showError(2, str_old);
return;
}
number[topNum - 1] = Math
.log(number[topNum - 1]);
topNum++;
break;
// 阶乘
case &#39;!&#39;:
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 &#39;+&#39;:
number[topNum - 2] += number[topNum - 1];
break;
case &#39;-&#39;:
number[topNum - 2] -= number[topNum - 1];
break;
case &#39;×&#39;:
number[topNum - 2] *= number[topNum - 1];
break;
// 涉及到除法时要考虑除数不能为零的情况
case &#39;÷&#39;:
if (number[topNum - 1] == 0) {
showError(1, str_old);
return;
}
number[topNum - 2] /= number[topNum - 1];
break;
case &#39;√&#39;:
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 &#39;^&#39;:
number[topNum - 2] = Math.pow(number[topNum - 2],
number[topNum - 1]);
break;
// sin
case &#39;s&#39;:
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 &#39;c&#39;:
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 &#39;t&#39;:
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 &#39;g&#39;:
if (number[topNum - 1] <= 0) {
showError(2, str_old);
return;
}
number[topNum - 1] = Math.log10(number[topNum - 1]);
topNum++;
break;
// 自然对数ln
case &#39;l&#39;:
if (number[topNum - 1] <= 0) {
showError(2, str_old);
return;
}
number[topNum - 1] = Math.log(number[topNum - 1]);
topNum++;
break;
// 阶乘
case &#39;!&#39;:
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");
}
}
}

<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>

Der obige Code wurde vom Editor eingeführt, um den Android-Rechnercode mit Klammern in Java zu implementieren. Ich frage auch Alle Helden, um Ihre wertvollen Meinungen abzugeben. Der Herausgeber wird sich rechtzeitig mit Ihnen in Verbindung setzen. Gleichzeitig bin ich allen sehr dankbar für die anhaltende Unterstützung der chinesischen PHP-Website.

Weitere Artikel zur Java-Implementierung von Android-Rechnercode mit Klammern finden Sie auf der chinesischen PHP-Website!