Android--简单计算器

文章目录

• 界面
• activity_main.xml
• 计算逻辑
• MainActivity.java
• ifReapet(String a)
• 计算优先级
• 功能实现测试

界面

activity_main.xml

• 采用GridLayout<网格布局>,将网格设置为8行4列,第2行为显示数据的文本标签,第2行为清除数据的按钮,3~6行为数字键和运算符;

<?xml version="1.0" encoding="utf-8"?>
<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:rowCount="8"// 设置为8行
    android:columnCount="4"// 设置为4列
    tools:context=".MainActivity">
    
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_columnSpan="4"
        android:layout_rowSpan="4" //TextView占4行4列
        android:layout_marginLeft="15sp"
        android:gravity="center_horizontal"
        android:text = "0"
        android:textSize="70dip"
        android:id="@+id/tv"
    />

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_columnSpan="4" //"清除键"占1行4列
        android:text= "清除"
        android:textSize="45dip"
        android:id="@+id/bt_clear"
    />

    <Button  android:text="1" android:textSize="40dip" android:id="@+id/bt_1"/>
    <Button  android:text="2" android:textSize="40dip" android:id="@+id/bt_2"/>
    <Button  android:text="3" android:textSize="40dip" android:id="@+id/bt_3" />
    <Button  android:text="+" android:textSize="40dip" android:id="@+id/bt_plus"/>

    <Button  android:text="4" android:textSize="40dip" android:id="@+id/bt_4"/>
    <Button  android:text="5" android:textSize="40dip" android:id="@+id/bt_5"/>
    <Button  android:text="6" android:textSize="40dip" android:id="@+id/bt_6"/>
    <Button  android:text="-" android:textSize="40dip" android:id="@+id/bt_minus" />

    <Button  android:text="7" android:textSize="40dip" android:id="@+id/bt_7"/>
    <Button  android:text="8" android:textSize="40dip" android:id="@+id/bt_8"/>
    <Button  android:text="9" android:textSize="40dip" android:id="@+id/bt_9"/>
    <Button  android:text="*" android:textSize="40dip" android:id="@+id/bt_multiply"/>

    <Button  android:text="." android:textSize="40dip" android:id="@+id/bt_point"/>
    <Button  android:text="0" android:textSize="40dip" android:id="@+id/bt_0"/>
    <Button  android:text="=" android:textSize="40dip" android:id="@+id/bt_equal"/>
    <Button  android:text="/" android:textSize="40dip" android:id="@+id/bt_divide"/>
</GridLayout>

• 界面显示效果
  

计算逻辑

MainActivity.java

• 通过MainActivity直接实现 OnClickListener接口,方便按钮添加监听器;
• 按钮的功能相识,逐个添加监听器,会使重复代码过多,代码冗余;
• 简化代码的同时,要注意各部件功能差异,"±*/."不能重复输出,要设置判断方法,检测是否重复输入;

public class MainActivity extends AppCompatActivity implements OnClickListener{
		Button bt_1;
	    Button bt_2;
	    Button bt_3;
	    .
	    .
	    .
	    private StringBuilder pending = new StringBuilder();
	    
	protected void onCreate(Bundle savedInstanceState) {
	        super.onCreate(savedInstanceState);
	        setContentView(R.layout.activity_main);
	        bt_0 = (Button) findViewById(R.id.bt_0);
	        bt_1 = (Button)findViewById(R.id.bt_1);
	        bt_2 = (Button)findViewById(R.id.bt_2);
	        .
	        .
	        .
	        tv_input = (TextView) findViewById(R.id.tv);
	        //与用户界面程序中组件建立关联;
	        //省略部分组件声明;
	
			bt_0.setOnClickListener(this);
	        bt_1.setOnClickListener(this);
	        bt_2.setOnClickListener(this);
	        .
	        .
	        .
	        bt_point.setOnClickListener(this);
	        //注册按钮的监听器;
			
			switch (v.getId()) {
	            case R.id.bt_0:
	                pending = pending.append("0");
	                tv_input.setText(pending);
	                break;
	            case R.id.bt_1:
	                pending = pending.append("1");
	                tv_input.setText(pending);
	                break;
	            case R.id.bt_2:
	                pending = pending.append("2");
	                tv_input.setText(pending);
	                break;
	            case R.id.bt_3:
	                pending = pending.append("3");
	                tv_input.setText(pending);
	                break;
	            .
	            .
	            .
	            case R.id.bt_plus: // 加
	                if (ifReapet("+")) {
	                    pending = pending.append("+");
	                    tv_input.setText(pending);
	                }
	                break;
	            case R.id.bt_minus: // 减
	                if (ifReapet("-")) {
	                    pending = pending.append("-");
	                    tv_input.setText(pending);
	                }
	                break;
	            case R.id.bt_multiply:// 乘
	                if (ifReapet("*")) {
	                    pending = pending.append("*");
	                    tv_input.setText(pending);
	                }
	                break;
	            case R.id.bt_divide: // 除
	                if (ifReapet("/")) {
	                    pending = pending.append("/");
	                    tv_input.setText(pending);
	                }
	                break;
	            case R.id.bt_point: //小数点
	                if (ifReapet(".")) {
	                    pending = pending.append(".");
	                    tv_input.setText(pending);
	                }
	                break;
	
	            case R.id.bt_clear: //清空
	                pending = pending.delete(0, pending.length());
	                tv_input.setText(pending);
	                break;
	            case R.id.bt_equal: // 等于
	                if ((pending.length() > 1)) {
	                    InfixInToDuffix inf = new InfixInToDuffix();
	                    String jieguo;
	                    try {
	                        String a = inf.toSuffix(pending);
	                        jieguo = inf.dealEquation(a);
	
	                    } catch (Exception ex) {
	                        jieguo = "出错";
	                    }
	                    tv_input.setText(pending + "=" + jieguo);
	                    pending = pending.delete(0, pending.length());
	                    if (Character.isDigit(jieguo.charAt(0))) {
	                        pending = pending.append(jieguo);
	                    }
	                }
	                break;
	            default:
	                break;
	        }
       }
 }

ifReapet(String a)

• private boolean ifReapet(String a): 通过传入的字符参数,进行判断,返回boolean值;
• 实现过程: 创建整数数组 b[],存放获取对应字符的位置数,pending.lastIndexOf() 获取对应字符的位置,存放到b[],通过判断b[]的长度,b[]为空,则说明为pending不存在对应字符,字符未重复输入,返回true;

private boolean ifReapet(String a) {
        //判断是否重复输入"+-*/."
        int[] b = new int[a.length()];
        int max;
        for (int i = 0; i < a.length(); i++) {
            String c = "" + a.charAt(i);
            //通过charAt(int i)获取字符
            b[i] = pending.lastIndexOf(c);
            //获取计算组内"+-*/."的位置
        }
        Arrays.sort(b);
        if (b[a.length() - 1] == -1) {
            max = 0;
        } else {
            max = b[a.length() - 1];
        }
        if (pending.indexOf(a, max) == -1) {
            //判断max不包含"+-*/.",输出为真
            return true;
        } else {
            return false;
        }
    }

计算优先级

• 关于计算优先级算法参考:中缀表达式转化为后缀表达式的
  http://write.blog.csdn.net/mdeditor
  后缀表达式的计算过程的
  http://www.nowamagic.net/librarys/veda/detail/2307

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.lang.*;
import java.util.ArrayList;
import java.util.*;

public class InfixInToDuffix {
    //使用集合定义好符号的运算优先级别
    private static final Map<Character,Integer>basic =new HashMap<Character, Integer>();
    static {
        basic.put('-',1);
        basic.put('+', 1);
        basic.put('*', 2);
        basic.put('/', 2);
        basic.put('(', 0);
        //basic.put('(', 0);
        //在运算中（）的优先级最高，但是此处因程序中需要故设置为0
    }


    //将中缀表达式转换为后缀表达式
    public String toSuffix(StringBuilder infix){
        List<String> queue = new ArrayList<String>(); 
        //定义队列用于存储数字以及最后的后缀表达式
        List<Character> stack = new ArrayList<Character>();                             
        //定义栈用于存储运算符最后stack中会被弹空

        char[] charArr = infix.substring(0,infix.length()).trim().toCharArray();                                    
        //字符数组用于拆分数字或符号
        String standard = "*/+-()";                                                        
        //判定标准 将表达式中会出现的运算符写出来
        char ch = '&';                                                                    
        //在循环中用来保存 字符数组的当前循环变量的  这里仅仅是初始化一个值  没有意义
        int len = 0;                                                                    
        //用于记录字符长度 【例如100*2,则记录的len为3 到时候截取字符串的前三位就是数字】
        for (int i = 0; i < charArr.length; i++) {                                        
        //开始迭代

            ch = charArr[i];                                                            
            //保存当前迭代变量
            if(Character.isDigit(ch)) {                                                    
            //如果当前变量为 数字
                len++;
            }else if(ch == '.'){                                                        
            //如果当前变量为  .  会出现在小数里面
                len++;
            }else if(standard.indexOf(ch) != -1) {                                        
            //如果是上面标准中的 任意一个符号
                if(len > 0) {                                                            
                //长度也有
                  queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len, i)));    
                    //说明符号之前的可以截取下来做数字
                    len = 0;                                                            
                    //长度置空
                }
                if(ch == '(') {                                                            
                //如果是左括号
                    stack.add(ch);                                                        
                    //将左括号 放入栈中
                    continue;                                                            
                    //跳出本次循环  继续找下一个位置
                }
                if (!stack.isEmpty()) {                                                    
                //如果栈不为empty
                    int size = stack.size() - 1;                                        
                    //获取栈的大小-1  即代表栈最后一个元素的下标
                    boolean flag = false;                                                
                    //设置标志位
                    while (size >= 0 && ch == ')' && stack.get(size) != '(') {           
                     //若当前ch为右括号，则 栈里元素从栈顶一直弹出，直到弹出到 左括号
                        queue.add(String.valueOf(stack.remove(size)));                    
                        //注意此处条件：ch并未入栈，所以并未插入队列中；同样直到找到左括号的时候，循环结束了，所以左括号也不会放入队列中【也就是：后缀表达式中不会出现括号】
                        size--;                                                            
                        //size-- 保证下标永远在栈最后一个元素【栈中概念：指针永远指在栈顶元素】
                        flag = true;                                                    
                        //设置标志位为true  表明一直在取（）中的元素
                    }
                    if(ch==')'&&stack.get(size) == '('){
                        flag = true;
                    }
                    while (size >= 0 && !flag && basic.get(stack.get(size)) >= basic.get(ch)) {    
                    //若取得不是（）内的元素，并且当前栈顶元素的优先级>=对比元素 那就出栈插入队列
                        queue.add(String.valueOf(stack.remove(size)));                    
                        //同样  此处也是remove()方法，既能得到要获取的元素，也能将栈中元素移除掉
                        size--;
                    }
                }
                if(ch != ')') {                                                            
                //若当前元素不是右括号
                    stack.add(ch);                                                        
                    //就要保证这个符号 入栈
                } else {                                                                
                //否则就要出栈 栈内符号
                    stack.remove(stack.size() - 1);
                }
            }
            if(i == charArr.length - 1) {                                                
            //如果已经走到了  中缀表达式的最后一位
                if(len > 0) {                                                            
                //如果len>0  就截取数字
                    queue.add(String.valueOf(Arrays.copyOfRange(charArr, i - len+1, i+1)));
                }
                int size = stack.size() - 1;                                            
                //size表示栈内最后一个元素下标
                while (size >= 0) {                                                        
                //一直将栈内  符号全部出栈 并且加入队列中  【最终的后缀表达式是存放在队列中的，而栈内最后会被弹空】
                    queue.add(String.valueOf(stack.remove(size)));
                    size--;
                }
            }
        }
        String a = queue.toString();
        return a.substring(1,a.length()-1);
    }


    public String dealEquation(String equation){

        String [] arr = equation.split(", ");                                    
        //根据, 拆分字符串
        List<String> list = new ArrayList<String>();                            
        //用于计算时  存储运算过程的集合【例如list中当前放置  100   20  5  /  则取出20/5 最终将结果4存入list   此时list中结果为  100  4 】


        for (int i = 0; i < arr.length; i++) {                                    
        //此处就是上面说的运算过程， 因为list.remove的缘故，所以取出最后一个数个最后两个数  都是size-2
            int size = list.size();
            switch (arr[i]) {
                case "+": double a = Double.parseDouble(list.remove(size-2))+ Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(a));     break;
                case "-": double b = Double.parseDouble(list.remove(size-2))- Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(b));     break;
                case "*": double c = Double.parseDouble(list.remove(size-2))* Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(c));     break;
                case "/": double d = Double.parseDouble(list.remove(size-2))/ Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(d));       break;
                default: list.add(arr[i]);     break;                                    
                //如果是数字  直接放进list中
            }
        }

        return list.size()
                == 1 ? list.get(0) : "运算失败" ;                   
                 //最终list中仅有一个结果，否则就是算错了
    }
}

功能实现测试

• 加法运算
  
• 减法运算
  - 乘法运算
  - 除法运算