0


Android——一个神奇的计算器APP

一个神奇的计算器APP

中缀运算

    中缀运算定义了两个栈,数字栈和符号栈;分别存储用户输入的数字(例如:1,2,3)和输入的符号(例如:+,-);
     下列视频以1+2+3/2*3%3为例;首先输入1,然后输入+,通过对运算符点击事件监听,将其分别纳入数字栈和符号栈,然后在输入2和+,即对+进行监听,并取出符号栈栈顶元素,判断其是否为初始化元素,若为否,则将数字栈栈顶元素取出,并获取拼接字符作为另外一个运算数字;(数字栈栈顶元素 &(代表符号栈栈顶元素)拼接字符串)(1+2);得到结果3之后将其压入数字栈中,并将第二个+号压入符号栈,用于下次运算;以此类推…

效果视频

运算

自定义圆形TextView

效果图

在这里插入图片描述

建立attr文件

通过对控件手势动作进行监听,改变按钮的样式;即按下为白色,松开为橙色

<resources>
    <declare-styleable name="SetCircle">
        <attr name="CircleColor" format="color"/>
        <attr name="SelectCircle" format="color"/>
    </declare-styleable>
</resources>

绘制圆形


    protected void onDraw(Canvas canvas) {
    //判断手势动作,改变控件状态
        if (isSelect){
            CirclePaint.setColor( SelectCircle );
        }else {
            CirclePaint.setColor( CircleColor );
        }
        //设置填充方式
        CirclePaint.setStyle( Paint.Style.FILL );
        //设置抗锯齿
        CirclePaint.setAntiAlias( true );
        RectF rectF = new RectF();
        //设置半径,比较长宽,取最大值
        int radius = getMeasuredWidth() > getMeasuredHeight() ? getMeasuredWidth() : getMeasuredHeight();
        rectF.set(getPaddingLeft(),getPaddingTop(),radius-getPaddingRight(),radius-getPaddingBottom());
        //绘制圆弧
        canvas.drawArc(rectF,0,360,false,CirclePaint);
        super.onDraw(canvas);
    }

字符拼接

通过StringBuilder将用户输入的数字进行拼接,段尾对复位按钮进行判断,将数字栈和符号栈以及拼接字符串的内容全部清空;

private class NumOnClick implements View.OnClickListener{
        @Override
        public void onClick(View view) {
            switch (view.getId()){
                case R.id.Zero:
                    numBuilder.append('0');
                    break;
                case R.id.One:
                    numBuilder.append('1');
                    break;
                case R.id.Two:
                    numBuilder.append('2');
                    break;
                case R.id.Three:
                    numBuilder.append('3');
                    break;
                case R.id.Four:
                    numBuilder.append('4');
                    break;
                case R.id.Five:
                    numBuilder.append('5');
                    break;
                case R.id.Six:
                    numBuilder.append('6');
                    break;
                case R.id.Seven:
                    numBuilder.append('7');
                    break;
                case R.id.Eight:
                    numBuilder.append('8');
                    break;
                case R.id.Nine:
                    numBuilder.append('9');
                    break;
                case R.id.Point:
                    numBuilder.append('.');
                    break;
                case R.id.Reset:
                    isReset = true;
            }
            if (isReset){
                PopStack();
                numBuilder.delete(0,numBuilder.length());
                ResultBox.setText("0");
                operatorStack.push('#');
                isReset = false;
            }else {
                ResultBox.setText(numBuilder.toString());
            }

        }
    }

清空栈内元素

清空数字栈和符号栈内元素

  private void PopStack(){
        while (numStack.isEmpty()){
            numStack.pop();
        }
        while (operatorStack.isEmpty()){
            operatorStack.pop();
        }
    }

运算执行

手势监听

此处以加运算符为例,对按下和松开两个事情进行监听,分别改变控件样式,并传入相应运算符进行运算

   private class OperatorOnClick implements View.OnTouchListener{

        @Override
        public boolean onTouch(View view, MotionEvent motionEvent) {
            boolean isPress = false;
            if (motionEvent.getAction() == MotionEvent.ACTION_DOWN){
                isPress = true;
            }
            switch (view.getId()){
                case R.id.Add:
                    if (isPress){
                        mAdd.IsSelect(true);
                        mAdd.setTextColor(getResources().getColor(R.color.normal));
                        StartOperation(ADD);
                    }else {
                        mAdd.IsSelect(false);
                        mAdd.setTextColor(getResources().getColor(R.color.select));
                    }
                    break;

入栈&&出栈

在初始化时,将符号栈压入‘#’符号,即代表第一次执行,不进行结果运算

operatorStack.push('#');
第一次运行时,即将符号栈栈顶元素取出,即‘#’,假如输入1和+,此时无法构成算式,因为确实另外一个运算数,即直接将其压入栈中,不进行结果运算;然后将拼接字符串清空,因为假如输入完了100和+,因为+号是不显示在用户界面的,如果不进行清空,之后输入的字符会追加在其之后,例如在输入50,即不清空为10050,会造成用户体验不良以及使用麻烦等缺点;

假如输入了100和+,然后输入50和-,构成100+50-算式,第一次不进行运算,如上释所示,第二次输入的-,即取出符号栈顶元素+,和运算数100和50,并将其传入EXEOperation()方法,开始运算结果

   private void StartOperation(char symbol){
        char operator = operatorStack.pop();
        if (operator == EQUAL){
            operatorStack.push(symbol);
        } else if (operator == '#'){
            numStack.push(numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()));
            operatorStack.push(symbol);
            numBuilder.delete(0,numBuilder.length());
        }else {
            switch (operator){
                case ADD:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()),ADD);
                    break;
                case SUB:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()),SUB);
                    break;
                case MULTIPLY:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()),MULTIPLY);
                    break;
                case DIVISION:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()),DIVISION);
                    break;
                case MOD:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()),MOD);
                    break;
                case EQUAL:
                    EXEOperation(numStack.pop(),numBuilder.toString().isEmpty()?0:Double.parseDouble(numBuilder.toString()));
                    break;
            }
        }
    }

运算结果

三个参数分别为第一个运算数,和另外一个运算数,以及符号栈栈顶元素,对符号进行判断,并进行结果运算,然后将结果压入栈中以及第二个运算符压人符合栈;
重点在于对等于键进行判断:
1:例如输入算式1+1-,对第二个运算符进行监听即可得到前一结果,然后在输入数字,符号,得到前一结果…
2:例如输入算式1+1=,此时并没有对等于符号进行监听,无法完成运算,解决办法为不将等于压入符号栈,直接结果入栈,相当于需要执行第一步才能完成运算

小数位判断

对结果字符串进行子串截取,判断小数点之后是否存在小数位,因为为double类型,默认会存在小数位。例如:
(1)1.0,则省略小数点后的0,直接输出0;
(2)1.05,则不进行小数位省略,直接输出

 //判断小数位之后是否有数字
        if (str.substring(str.indexOf('.') + 1, str.length() - 1).isEmpty()) {
            str = str.substring(0, str.indexOf('.'));
        }

运算代码

    private void EXEOperation(double front,double rear,char operator) {
        double result = 0;
        String str;
        /**
         * 对连续点击运算符,而运算数字并未符合标准时进行判断
         * 例如:12+
         * 此时12和+分别进栈,此时若再点击运算符+,则无法进行运算,因为rear运算数为空*/
        switch (operator) {
            case ADD:
                result = front + rear;
                break;
            case SUB:
                result = front - rear;
                break;
            case MULTIPLY:
                result = front * rear;
                break;
            case DIVISION:
                result = front / rear;
                break;
            case MOD:
                result = front < rear ? front :front % rear;
                break;
        }
        numStack.push(result);
        if (isReturn){
            operatorStack.push(EQUAL);
        }else {
            operatorStack.push(operator);
            isReturn = false;
        }
        str = String.valueOf(result);
        //判断小数位之后是否有数字
        if (str.substring(str.indexOf('.') + 1, str.length() - 1).isEmpty()) {
            str = str.substring(0, str.indexOf('.'));
        }
        ResultBox.setText(str);
        //前运算符清空,为后运算符输入做准备
        numBuilder.delete(0,numBuilder.length());
    }

任意进制转换

通过输入十进制数,分别转化为相应的二进制,八进制,十六进制数

效果视频

转换进制

进制转换

因为需要分别转化多个进制,无法对其数组长度进行判断,即将每个数字首元素作为存储数组长度的地址

   private int[] Conversion(int num,int binary){
     int[] remainder = new int[255];
     int count = 1;
     do {
         remainder[count++] = num%binary;
         num /= binary;
     } while (num != 0);
     remainder[0] = count;
     return remainder;
    }

结果逆置

通过对解析的进制数组进行逆置,因为十六进制的10——A,11——B…,所以需要对其进行判断,然后使用字符串拼接,最终返回一个结果字符串

    private String Inversion(int[] array){
            StringBuilder builder = new StringBuilder();
        for (int i = array[0]-1; i >=1 ; i--) {
            if (array[i] == 10){
                builder.append("A");
            }else if (array[i] == 11){
                builder.append("B");
            }else if (array[i] == 12){
                builder.append("C");
            }else if (array[i] == 13){
                builder.append("D");
            }else if (array[i] == 14){
                builder.append("E");
            }else if (array[i] == 15){
                builder.append("F");
            }else {
                builder.append(array[i]);
            }
        }
        return builder.toString();
    }

结果返回

int num = Integer.parseInt(ResultBox.getText().toString());
Binary_2.setText(Inversion(Conversion(num,2)));
Binary_8.setText(Inversion(Conversion(num,8)));
Binary_10.setText(Inversion(Conversion(num,10)));
Binary_16.setText(Inversion(Conversion(num,16)));

本文转载自: https://blog.csdn.net/News53231323/article/details/123234328
版权归原作者 FranzLiszt1847 所有, 如有侵权,请联系我们删除。

“Android&mdash;&mdash;一个神奇的计算器APP”的评论:

还没有评论