android GradLayout实现计算器

主界面 

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

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

    android:id="@+id/root"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:columnCount="4"

    android:rowCount="6"

    tools:context="com.ssln.gridlayoutcalc.MainActivity" >



    <TextView

        android:id="@+id/tvResult"

        android:layout_column="0"

        android:layout_columnSpan="4"

        android:layout_row="0"

        android:background="#eee"

        android:lines="1"

        android:minLines="1"

        android:textColor="#000"

        android:padding="5dp"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:textSize="50sp" />



    <Button

        android:id="@+id/btnClear"

        android:layout_columnSpan="4"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="清除" />



</GridLayout>

 

main.java

package com.ssln.gridlayoutcalc;

 

import android.app.Activity;

import android.os.Bundle;

import android.view.Gravity;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.GridLayout;

import android.widget.TextView;



public class MainActivity extends Activity implements OnClickListener{



    private GridLayout gridLayout;

    private Button btnClear;

    private TextView tvResult;

    private String[] btns=new String[]{

        "7","8","9","/",

        "4","5","6","x",

        "1","2","3","-",

        ".","0","=","+"

    };

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        

        

        gridLayout=(GridLayout)findViewById(R.id.root);

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

        tvResult=(TextView)findViewById(R.id.tvResult);

        

        btnClear.setOnClickListener(this);

        

        for (int i = 0; i < btns.length; i++) {

             Button btn=new Button(this);

             btn.setText(btns[i]);

             btn.setTextSize(40);

             //设置所在行，+2是因为上面有两行了，一行显示一行按钮

             GridLayout.Spec rowSpec=GridLayout.spec(i/4+2);

             //设置第几列

             GridLayout.Spec colSpec=GridLayout.spec(i%4);

             GridLayout.LayoutParams params=new GridLayout.LayoutParams(rowSpec,colSpec);

             //占满父容器

             params.setGravity(Gravity.FILL);

             

             btn.setOnClickListener(this);

             

             gridLayout.addView(btn,params);

            

        }

    }

    @Override

    public void onClick(View v) {

         if(v==btnClear)

         {

             tvResult.setText("");

         }

         else

         {

             String btnText=((Button)v).getText().toString();

             tvResult.setText(tvResult.getText().toString()+btnText);

             if(btnText.equals("="))

             {

                 Calc calc=new Calc(tvResult.getText().toString());

                 String[] Rpn=calc.expToRpn().split(",");

                 double dbResult=calc.CalcRpn(Rpn);

                 tvResult.setText(String.valueOf(dbResult));

                 

             }

         }

    }



}

 

逆波兰算法

package com.ssln.gridlayoutcalc;



import java.util.HashMap;

import java.util.Map;

import java.util.Stack;



/**

 *  逆波兰式 Reverse Polish Notation 

 * @author xcj

 *

 */

public class Calc {



    //操作数

    private Stack<Double> calcStack=new Stack<Double>();

    //操作符

    private Stack<String> operatorStack=new Stack<String>();

    

    //操作符优先级

    private Map<String,Integer> priorityMap=new HashMap<String,Integer>();

    

    private String Expression;//计算表达式

    

    private Double calcResult=0.0d; //计算结果

    

    public Calc(String exp) {

         Expression=exp;

         priorityMap.put("+", 0);

         priorityMap.put("-", 0);

         priorityMap.put("x", 1);

         priorityMap.put("/", 1);

    }

    

    /**

     * 获取操作符优先级

     * @param operator

     * @return

     */

    public int getPriority(String operator)

    {

        return priorityMap.get(operator);

    }

    

    /**

     * 判断是否最高优先级

     * @param operator

     * @return

     */

    public boolean isHighpriority(String operator)

    {

        int operPrio=getPriority(operator); //获取优先级

        if(!operatorStack.empty())

        {

            for (String str : operatorStack) {

                int currPrio=getPriority(str);

                if(operPrio<currPrio)

                    return false;

            }

        }

        return true;

    }

    

    /**

     * 表达式转换为逆波兰

     * @return

     */

    public String expToRpn(){

        int index=0,end=0;

        String Rpn="";

        for (int i = 0; i < Expression.length(); i++) {

         String tmp=String.valueOf(Expression.charAt(i));

        //如果是数字，就把结束符加1

         if(tmp.matches("[0-9.]"))

         {

             end++;

         }

         else

         {

             //获取得到的操作数

             String calcStr=Expression.substring(index,end);

             Rpn+=calcStr+","; //加入操作数

             //取得操作符

             int endx=end+1;

             String calcOper=Expression.substring(end,endx);

             end++;

             if(calcOper.equals("="))//如果要计算结果了

             {

                 while(!operatorStack.empty())

                 {

                     //将所有的操作符放入RpN

                     Rpn+=operatorStack.pop()+",";

                 }

             }

             else

             {

                 if(isHighpriority(calcOper))

                 {

                     //如果优先级较高,压入堆栈

                     operatorStack.push(calcOper);

                 }

                 else

                 {

                     //如果不是最高的,将最高的放到前面

                     while(!operatorStack.empty())

                     {

                         Rpn+=operatorStack.pop()+",";

                     }

                     operatorStack.push(calcOper);

                 }

                 index=end;

             }

         }

        }

         return Rpn;

    }

    

    /**

     * 根据逆波兰计算

     * @param Rpn

     * @return

     */

    public double CalcRpn(String[] Rpn)

    {

        for (int i = 0; i < Rpn.length; i++) {

            String str = Rpn[i];

            if(str.matches("^[0-9]+.?[0-9]*$"))

            {

                //如果是数字,压入操作数堆栈

                calcStack.push(Double.parseDouble(str));

            }

            else

            {

                //计算数值

                CalcOperator(str);

            }

        }

        return calcResult;

    }

    

    /**

     * 计算数值 

     * @param operator

     */

    private void CalcOperator(String operator)

    {

        double d1=calcStack.pop();

        double d2=calcStack.pop();

        if(operator.equals("+"))

            calcResult=d2+d1;  

        if(operator.equals("-"))  

            calcResult=d2-d1;  

        if(operator.equals("x"))  

            calcResult=d2*d1;  

        if(operator.equals("/"))  

            calcResult=d2/d1;  

        

        //结果再次放入栈

         calcStack.push(calcResult);  

    }



    public String getExpression() {

        return Expression;

    }



    public void setExpression(String expression) {

        Expression = expression;

    }



 



}

效果,用自制的GIF动画录制录制的