android 简单的计算器的源码

首先是功能需求分析：

1、数字我规定最长为九位，如果有小数点则加上小数点最长为十位

2、第二个参数输入时不允许为负数，但是先得出的结果为负数，可以再进行运算（比如：1-2=-1，结果显示的是-1，可以再运算，-1+2=1）

3、得出的结果如果大于等于10位，则把数据进行科学计数

4、科学计数的数据不能再进行运算，再按按钮会直接显示0或者当前按下的数字

5、进行连续运算时，会先计算先一个运算的结果，在把结果作为第一个参数进行下次运算（比如：1+2+3，当按下第二个加号的时候，会显示3+，先把前一个运算的结果算出来再进行下一个运算）

6、当除数为0时，显示 error

7、默认情况下，显示 0

8、是否进行运算过，判断是否按下过等于号，如果按下，显示了结果，再按数字则直接显示当前数字而不是在结果后添加这个数字

 

接下来是正式开始编写代码：

1、界面布局 （TableLayout 实现按钮排版 ，EditText 显示表达式或值）

2、初始化所有控件，以及为需要点击事件的控件绑定监听器

3、编写监听器事件逻辑代码

①当按下的是数字，先判断是否计算过

----是（按下过等号）：把显示的文本改为当前按下的数字，计算过的标志设为false

----否（没按过等号）：进行下一步判断，计算过的标志设为false

--------判断当前文本是否有科学计数

--------是（有科学计数的标志 e ）：文本置为 0

--------判断文本是否只有一个 0

--------是（当前文本为 0）：文本置为空

--------判断是否有运算符

--------是（包含运算符）：取出运算符后的第二个参数，进行下一步判断

------------判断最后一个是否是运算符

------------是（文本最后一个是运算符号）：则直接添加按下的数字

------------否（文本最后一个不是运算符号）：进行下一步判断

----------------判断第二个参数的长度，包括小数点则可以为10位，不包括小数点只能为9位

--------否（不包含运算符）：判断第一个参数（即整个文本）的长度，包括小数点则可以为10位，不包括小数点只能为9位

 

②当按下的是小数点，先判断是否计算过

----是（按下过等号）：把文本改为 0. （数字 0 的后面有一个小数点），把计算过的标志位设为 false

----否（没按过等号）：进行下一步判断，，把计算过的标志位设为 false

--------判断是否有运算符

--------是（包含运算符）：取出第二个参数，判断长度是否超过，是：无操作，否：判断参数中是否已经有小数点，有：无操作，否，添加小数点

--------否（不包含运算符）：判断第一个参数（即整个文本）的长度是否超过，是：无操作，否：判断参数中是否已经有小数点，有：无操作，否，添加小数点

 

③当按下的是特殊键（归零、回退、百分比）

----归零：直接把文本改为 0

----回退：判断文本是否是 error，是：文本改为 0，否：判断文本的长度，当文本的长度大于0时且不等于1时，文本删掉最后一个字符，文本长度为1时，文本改为 0

----百分比：判断文

 

本是否是 error，是：无操作，否：判断是否是表达式，是：无操作，否：数字除百

 

④当按下的是运算符，判断当前的文本是否是科学计数

----是（文本是科学计数，包含 e）：文本置 0

----否（文本不是科学计数，不包含 e）：进行下一步判断，且第二个参数不为空

--------判断文本是否是表达式

--------是（是表达式，有两个参数）：先得出结果，如果结果不是 error，添加上相应的运算符，如果结果是 error，无操作

--------否（不是表达式，可能是数字，也可能是数字后面带一个运算符）：如果计算过的标志位为 true，改为 false，如果最后一个字符为其他运算符，则改为当前按下的运算符，如果最后一个不是当前按下的运算符，则添加改运算符

 

⑤当按下的是等号，判断当前文本是否是表达式

----是：判断包含的是哪种运算符，取出两个参数，如果第二个参数为空，则无操作，如果第二个参数不为空，则进行相应的计算，再把运算结果进行格式化，然后用正则表达式去掉多余的 0  。如果结果的长度大于10位，则把数字转换成科学计数

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

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".MainActivity" >

<TextView

android:id="@+id/map"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="欢迎来到么么哒计算器"/>

<EditText

android:id="@+id/mResultText"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_marginTop="20dp"

android:hint="请输入"

/>

<TableLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_marginTop="80dp">

<TableRow

android:layout_width="match_parent"

android:layout_height="wrap_content"

>

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="AC"

android:id="@+id/ac_btn" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="Del"

android:id="@+id/delete_btn" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="%"

android:id="@+id/percent_btn" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="÷"

android:id="@+id/divide_btn" />

</TableRow>

<TableRow

android:layout_width="match_parent"

android:layout_height="wrap_content">

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="7"

android:id="@+id/num_seven" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="8"

android:id="@+id/num_eight" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="9"

android:id="@+id/num_nine" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="×"

android:id="@+id/multiply_btn" />

</TableRow>

<TableRow

android:layout_width="match_parent"

android:layout_height="wrap_content">

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="4"

android:id="@+id/num_four" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="5"

android:id="@+id/num_five" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="6"

android:id="@+id/num_six" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="-"

android:id="@+id/subtract_btn" />

</TableRow>

<TableRow

android:layout_width="match_parent"

android:layout_height="wrap_content">

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="1"

android:id="@+id/num_one" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="2"

android:id="@+id/num_two" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="3"

android:id="@+id/num_three" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="+"

android:id="@+id/plus_btn" />

</TableRow>

<TableRow

android:layout_width="match_parent"

android:layout_height="wrap_content">

<Button

android:layout_width="0dp"

android:layout_weight="2"

android:layout_height="70dp"

android:textSize="22sp"

android:text="0"

android:id="@+id/num_zero" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="."

android:id="@+id/dot_btn" />

<Button

android:layout_width="0dp"

android:layout_weight="1"

android:layout_height="70dp"

android:textSize="22sp"

android:text="="

android:id="@+id/equal_btn" />

</TableRow>

</TableLayout>



</RelativeLayout>

布局文件写完就会呈现出这样得界面，要开始写逻辑文件了，逻辑清晰很重要

package com.example.android_lucky;



import android.app.Activity;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.EditText;



public class MainActivity extends Activity implements OnClickListener{

/**

* 数字

*/

private Button num0;

private Button num1;

private Button num2;

private Button num3;

private Button num4;

private Button num5;

private Button num6;

private Button num7;

private Button num8;

private Button num9;

/**

* 运算符

*/

private Button plus_btn;

private Button subtract_btn;

private Button multiply_btn;

private Button divide_btn;

private Button equal_btn;

/**

* 其他

*/

private Button dot_btn;

private Button percent_btn;

private Button delete_btn;

private Button ac_btn;

/**

* 结果

*/

private EditText mResultText;

/**

* 已经输入的字符

*/

private String existedText = "";

/**

* 是否计算过

*/

private boolean isCounted = false;

/**

* 以负号开头，且运算符不是是减号

* 例如：-21×2

*/

private boolean startWithOperator = false;

/**

* 以负号开头，且运算符是减号

* 例如：-21-2

*/

private boolean startWithSubtract = false;

/**

* 不以负号开头，且包含运算符

* 例如：21-2

*/

private boolean noStartWithOperator = false;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

initView();

initEvent();

}

/**

* 初始化控件

*/

private void initView() {

/**

* 数字

*/

num0 = (Button) findViewById(R.id.num_zero);

num1 = (Button) findViewById(R.id.num_one);

num2 = (Button) findViewById(R.id.num_two);

num3 = (Button) findViewById(R.id.num_three);

num4 = (Button) findViewById(R.id.num_four);

num5 = (Button) findViewById(R.id.num_five);

num6 = (Button) findViewById(R.id.num_six);

num7 = (Button) findViewById(R.id.num_seven);

num8 = (Button) findViewById(R.id.num_eight);

num9 = (Button) findViewById(R.id.num_nine);

/**

* 运算符

*/

plus_btn = (Button) findViewById(R.id.plus_btn);

subtract_btn = (Button) findViewById(R.id.subtract_btn);

multiply_btn = (Button) findViewById(R.id.multiply_btn);

divide_btn = (Button) findViewById(R.id.divide_btn);

equal_btn = (Button) findViewById(R.id.equal_btn);

/**

* 其他

*/

dot_btn = (Button) findViewById(R.id.dot_btn);

percent_btn = (Button) findViewById(R.id.percent_btn);

delete_btn = (Button) findViewById(R.id.delete_btn);

ac_btn = (Button) findViewById(R.id.ac_btn);

/**

* 结果

*/

mResultText = (EditText) findViewById(R.id.mResultText);

/**

* 已经输入的字符

*/

existedText = mResultText.getText().toString();

}

/**

* 初始化事件

*/

private void initEvent() {

num0.setOnClickListener(this);

num1.setOnClickListener(this);

num2.setOnClickListener(this);

num3.setOnClickListener(this);

num4.setOnClickListener(this);

num5.setOnClickListener(this);

num6.setOnClickListener(this);

num7.setOnClickListener(this);

num8.setOnClickListener(this);

num9.setOnClickListener(this);

plus_btn.setOnClickListener(this);

subtract_btn.setOnClickListener(this);

multiply_btn.setOnClickListener(this);

divide_btn.setOnClickListener(this);

equal_btn.setOnClickListener(this);

dot_btn.setOnClickListener(this);

percent_btn.setOnClickListener(this);

delete_btn.setOnClickListener(this);

ac_btn.setOnClickListener(this);

}

/**

* 点击事件

* @param v 点击的控件

*/

@Override

public void onClick(View v) {

switch (v.getId()){

/**

* 数字

*/

case R.id.num_zero:

existedText = isOverRange(existedText,"0");

break;

case R.id.num_one:

existedText = isOverRange(existedText,"1");

break;

case R.id.num_two:

existedText = isOverRange(existedText,"2");

break;

case R.id.num_three:

existedText = isOverRange(existedText,"3");

break;

case R.id.num_four:

existedText = isOverRange(existedText,"4");

break;

case R.id.num_five:

existedText = isOverRange(existedText,"5");

break;

case R.id.num_six:

existedText = isOverRange(existedText,"6");

break;

case R.id.num_seven:

existedText = isOverRange(existedText,"7");

break;

case R.id.num_eight:

existedText = isOverRange(existedText,"8");

break;

case R.id.num_nine:

existedText = isOverRange(existedText,"9");

break;

/**

* 运算符

*/

case R.id.plus_btn:

/**

* 判断已有的字符是否是科学计数

* 是 置零

* 否 进行下一步

*

* 判断表达式是否可以进行计算

* 是 先计算再添加字符

* 否 添加字符

*

* 判断计算后的字符是否是 error

* 是 置零

* 否 添加运算符

*/

if (!existedText.contains("e")) {

if (judgeExpression()) {

existedText = getResult();

if (existedText.equals("error")){

} else {

existedText += "+";

}

} else {

if (isCounted) {

isCounted = false;

}

if ((existedText.substring(existedText.length() - 1)).equals("-")) {

existedText = existedText.replace("-", "+");

} else if ((existedText.substring(existedText.length() - 1)).equals("×")) {

existedText = existedText.replace("×", "+");

} else if ((existedText.substring(existedText.length() - 1)).equals("÷")) {

existedText = existedText.replace("÷", "+");

} else if (!(existedText.substring(existedText.length() - 1)).equals("+")) {

existedText += "+";

}

}

} else {

existedText = "0";

}

break;

case R.id.subtract_btn:

if (!existedText.contains("e")) {

if (judgeExpression()) {

existedText = getResult();

if (existedText.equals("error")){

} else {

existedText += "-";

}

} else {

if (isCounted) {

isCounted = false;

}

if ((existedText.substring(existedText.length() - 1)).equals("+")) {

// Log.d("Anonymous", "onClick: " + "进入减法方法");

existedText = existedText.replace("+", "-");

} else if ((existedText.substring(existedText.length() - 1)).equals("×")) {

existedText = existedText.replace("×", "-");

} else if ((existedText.substring(existedText.length() - 1)).equals("÷")) {

existedText = existedText.replace("÷", "-");

} else if (!(existedText.substring(existedText.length() - 1)).equals("-")) {

existedText += "-";

}

}

} else {

existedText = "0";

}

break;

case R.id.multiply_btn:

if (!existedText.contains("e")) {

if (judgeExpression()) {

existedText = getResult();

if (existedText.equals("error")){

} else {

existedText += "×";

}

} else {

if (isCounted) {

isCounted = false;

}

if ((existedText.substring(existedText.length() - 1)).equals("+")) {

existedText = existedText.replace("+", "×");

} else if ((existedText.substring(existedText.length() - 1)).equals("-")) {

existedText = existedText.replace("-", "×");

} else if ((existedText.substring(existedText.length() - 1)).equals("÷")) {

existedText = existedText.replace("÷", "×");

} else if (!(existedText.substring(existedText.length() - 1)).equals("×")) {

existedText += "×";

}

}

} else {

existedText = "0";

}

break;

case R.id.divide_btn:

if (!existedText.contains("e")) {

if (judgeExpression()) {

existedText = getResult();

if (existedText.equals("error")){

} else {

existedText += "÷";

}

} else {

if (isCounted) {

isCounted = false;

}

if ((existedText.substring(existedText.length() - 1)).equals("+")) {

existedText = existedText.replace("+", "÷");

} else if ((existedText.substring(existedText.length() - 1)).equals("-")) {

existedText = existedText.replace("-", "÷");

} else if ((existedText.substring(existedText.length() - 1)).equals("×")) {

existedText = existedText.replace("×", "÷");

} else if (!(existedText.substring(existedText.length() - 1)).equals("÷")) {

existedText += "÷";

}

}

} else {

existedText = "0";

}

break;

case R.id.equal_btn:

existedText = getResult();

isCounted = true;

break;

/**

* 其他

*/

case R.id.dot_btn:

/**

* 判断是否运算过

* 否

* 判断是否有运算符，有 判断运算符之后的数字，无 判断整个数字

* 判断数字是否过长，是则不能添加小数点，否则可以添加

* 判断已经存在的数字里是否有小数点

* 是

* 字符串置为 0.

*/

if (!isCounted){

if (existedText.contains("+") || existedText.contains("-") ||

existedText.contains("×") || existedText.contains("÷") ){

String param1 = null;

String param2 = null;

if (existedText.contains("+")) {

param1 = existedText.substring(0, existedText.indexOf("+"));

param2 = existedText.substring(existedText.indexOf("+") + 1);

} else if (existedText.contains("-")) {

param1 = existedText.substring(0, existedText.indexOf("-"));

param2 = existedText.substring(existedText.indexOf("-") + 1);

} else if (existedText.contains("×")) {

param1 = existedText.substring(0, existedText.indexOf("×"));

param2 = existedText.substring(existedText.indexOf("×") + 1);

} else if (existedText.contains("÷")) {

param1 = existedText.substring(0, existedText.indexOf("÷"));

param2 = existedText.substring(existedText.indexOf("÷") + 1);

}

Log.d("Anonymous param1",param1);

Log.d("Anonymous param2",param2);

boolean isContainedDot = param2.contains(".");

if (param2.length() >= 9){

} else if (!isContainedDot){

if (param2.equals("")){

existedText += "0.";

} else {

existedText += ".";

}

} else {

return;

}

} else {

boolean isContainedDot = existedText.contains(".");

if (existedText.length() >= 9){

} else if (!isContainedDot){

existedText += ".";

} else {

return;

}

}

isCounted = false;

} else {

existedText = "0.";

isCounted = false;

}

break;

case R.id.percent_btn:

/**

* 判断数字是否有运算符

* 是 不做任何操作

* 否 进行下一步

*

* 判断数字是否是 0

* 是 不做任何操作

* 否 进行除百

*

* 将字符串转换成double类型，进行运算后，再转换成String型

*/

if (existedText.equals("error")){

} else {

getCondition();

if (startWithOperator || startWithSubtract || noStartWithOperator) {

} else {

if (existedText.equals("0")) {

return;

} else {

double temp = Double.parseDouble(existedText);

temp = temp / 100;

existedText = String.valueOf(temp);

}

}

}

break;

case R.id.delete_btn:

/**

* 字符串长度大于 0 时才截取字符串

* 如果长度为 1，则直接把字符串设置为 0

*/

if (existedText.equals("error")){

existedText = "0";

} else if (existedText.length() > 0){

if (existedText.length() == 1) {

existedText = "0";

} else {

existedText = existedText.substring(0,existedText.length()-1);

}

}

break;

case R.id.ac_btn:

existedText = "0";

break;

}

/**

* 设置显示

*/

mResultText.setText(existedText);

}

/**

* 进行运算，得到结果

* @return 返回结果

*/

private String getResult() {

/**

* 结果

*/

String tempResult = null;

/**

* 两个String类型的参数

*/

String param1 = null;

String param2 = null;

/**

* 转换后的两个double类型的参数

*/

double arg1 = 0;

double arg2 = 0;

double result = 0;

getCondition();

/**

* 如果有运算符，则进行运算

* 没有运算符，则把已经存在的数据再传出去

*/

if ( startWithOperator || noStartWithOperator || startWithSubtract) {

if (existedText.contains("+")) {

/**

* 先获取两个参数

*/

param1 = existedText.substring(0, existedText.indexOf("+"));

param2 = existedText.substring(existedText.indexOf("+") + 1);

/**

* 如果第二个参数为空，则还是显示当前字符

*/

if (param2.equals("")){

tempResult = existedText;

} else {

/**

* 转换String为Double

* 计算后再转换成String类型

* 进行正则表达式处理

*/

arg1 = Double.parseDouble(param1);

arg2 = Double.parseDouble(param2);

result = arg1 + arg2;

tempResult = String.format("%f", result);

tempResult = subZeroAndDot(tempResult);

}

} else if (existedText.contains("×")) {

param1 = existedText.substring(0, existedText.indexOf("×"));

param2 = existedText.substring(existedText.indexOf("×") + 1);

if (param2.equals("")){

tempResult = existedText;

} else {

arg1 = Double.parseDouble(param1);

arg2 = Double.parseDouble(param2);

result = arg1 * arg2;

tempResult = String.format("%f", result);

tempResult = subZeroAndDot(tempResult);

}

} else if (existedText.contains("÷")) {

param1 = existedText.substring(0, existedText.indexOf("÷"));

param2 = existedText.substring(existedText.indexOf("÷") + 1);

if (param2.equals("0")){

tempResult = "error";

} else if (param2.equals("")){

tempResult = existedText;

} else {

arg1 = Double.parseDouble(param1);

arg2 = Double.parseDouble(param2);

result = arg1 / arg2;

tempResult = String.format("%f", result);

tempResult = subZeroAndDot(tempResult);

}

} else if (existedText.contains("-")) {

/**

* 这里是以最后一个 - 号为分隔去取出两个参数

* 进到这个方法，必须满足有运算公式

* 而又避免了第一个参数是负数的情况

*/

param1 = existedText.substring(0, existedText.lastIndexOf("-"));

param2 = existedText.substring(existedText.lastIndexOf("-") + 1);

if (param2.equals("")){

tempResult = existedText;

} else {

arg1 = Double.parseDouble(param1);

arg2 = Double.parseDouble(param2);

result = arg1 - arg2;

tempResult = String.format("%f", result);

tempResult = subZeroAndDot(tempResult);

}

}

/**

* 如果数据长度大于等于10位，进行科学计数

*

* 如果有小数点，再判断小数点前是否有十个数字，有则进行科学计数

*/

if (tempResult.length() >= 10) {

tempResult = String.format("%e", Double.parseDouble(tempResult));

} else if (tempResult.contains(".")) {

if (tempResult.substring(0, tempResult.indexOf(".")).length() >= 10) {

tempResult = String.format("%e", Double.parseDouble(tempResult));

}

}

} else {

tempResult = existedText;

}

return tempResult;

}

/**

* 先判断是否按过等于号

* 是 按数字则显示当前数字

* 否 在已有的表达式后添加字符

*

* 判断数字是否就是一个 0

* 是 把字符串设置为空字符串。

* 1、打开界面没有运算过的时候，AC键归零或删除完归零的时候，会显示一个 0

* 2、当数字是 0 的时候，设置成空字符串，再按 0 ，数字会还是 0，不然可以按出 000 这种数字

* 否 添加按下的键的字符

*

* 判断数字是否包含小数点

* 是 数字不能超过十位

* 否 数字不能超过九位

*

* 进行上面的判断后，再判断数字是否超过长度限制

* 超过不做任何操作

* 没超过可以再添数字

*/

private String isOverRange(String existedText, String s) {

/**

* 判断是否计算过

*/

if (!isCounted){

/**

* 判断是否是科学计数

* 是 文本置零

*/

if (existedText.contains("e")){

existedText = "0";

}

/**

* 判断是否只有一个 0

* 是 文本清空

*/

if (existedText.equals("0")){

existedText = "";

}

/**

* 判断是否有运算符

* 是 判断第二个数字

* 否 判断整个字符串

*/

if (existedText.contains("+") || existedText.contains("-") ||

existedText.contains("×") || existedText.contains("÷")){

/**

* 包括运算符时 两个数字 判断第二个数字

* 两个参数

*/

String param2 = null;

if (existedText.contains("+")){

param2 = existedText.substring(existedText.indexOf("+")+1);

} else if (existedText.contains("-")){

param2 = existedText.substring(existedText.indexOf("-")+1);

} else if (existedText.contains("×")){

param2 = existedText.substring(existedText.indexOf("×")+1);

} else if (existedText.contains("÷")){

param2 = existedText.substring(existedText.indexOf("÷")+1);

}

// Log.d("Anonymous param1",param1);

// Log.d("Anonymous param2",param2);

if (existedText.substring(existedText.length()-1).equals("+") ||

existedText.substring(existedText.length()-1).equals("-") ||

existedText.substring(existedText.length()-1).equals("×") ||

existedText.substring(existedText.length()-1).equals("÷")){

existedText += s;

} else {

if (param2.contains(".")){

if (param2.length() >= 10){

} else {

existedText += s;

}

} else {

if (param2.length() >= 9){

} else {

existedText += s;

}

}

}

} else {

/**

* 不包括运算符时 一个数字

*/

if (existedText.contains(".")){

if (existedText.length() >= 10){

} else {

existedText += s;

}

} else {

if (existedText.length() >= 9){

} else {

existedText += s;

}

}

}

isCounted = false;

} else {

existedText = s;

isCounted = false;

}

return existedText;

}

/**

* 使用java正则表达式去掉多余的.与0

* @param s 传入的字符串

* @return 修改之后的字符串

*/

public static String subZeroAndDot(String s){

if(s.indexOf(".") > 0){

s = s.replaceAll("0+?$", "");//去掉多余的0

s = s.replaceAll("[.]$", "");//如最后一位是.则去掉

}

return s;

}

/**

* 判断表达式

*

* 为了按等号是否进行运算

* 以及出现两个运算符（第一个参数如果为负数的符号不计）先进行运算再添加运算符

*/

private boolean judgeExpression() {

getCondition();

String tempParam2 = null;

if ( startWithOperator || noStartWithOperator || startWithSubtract) {

if (existedText.contains("+")) {

/**

* 先获取第二个参数

*/

tempParam2 = existedText.substring(existedText.indexOf("+") + 1);

/**

* 如果第二个参数为空，表达式不成立

*/

if (tempParam2.equals("")) {

return false;

} else {

return true;

}

} else if (existedText.contains("×")) {

tempParam2 = existedText.substring(existedText.indexOf("×") + 1);

if (tempParam2.equals("")) {

return false;

} else {

return true;

}

} else if (existedText.contains("÷")) {

tempParam2 = existedText.substring(existedText.indexOf("÷") + 1);

if (tempParam2.equals("")) {

return false;

} else {

return true;

}

} else if (existedText.contains("-")) {

/**

* 这里是以最后一个 - 号为分隔去取出两个参数

* 进到这个方法，必须满足有运算公式

* 而又避免了第一个参数是负数的情况

*/

tempParam2 = existedText.substring(existedText.lastIndexOf("-") + 1);

if (tempParam2.equals("")) {

return false;

} else {

return true;

}

}

}

return false;

}

/**

* 取得判断条件

*/

private void getCondition() {

/**

* 以负号开头，且运算符不是是减号

* 例如：-21×2

*/

startWithOperator = existedText.startsWith("-") && ( existedText.contains("+") ||

existedText.contains("×") || existedText.contains("÷") );

/**

* 以负号开头，且运算符是减号

* 例如：-21-2

*/

startWithSubtract = existedText.startsWith("-") && ( existedText.lastIndexOf("-") != 0 );

/**

* 不以负号开头，且包含运算符

* 例如：21-2

*/

noStartWithOperator = !existedText.startsWith("-") && ( existedText.contains("+") ||

existedText.contains("-") || existedText.contains("×") || existedText.contains("÷"));

}

}