在Android studio中制作一个没有优先级，输入多个零只显示一个的多运算计算器

好的，我理解您的问题了。下面是制作一个没有优先级，输入多个零只显示一个的多运算计算器的步骤：

1. 首先，在Android Studio中创建一个新项目，并在布局文件中添加一个TextView用于显示输入和计算结果，以及多个Button用于输入数字和运算符。

2. 在Activity中，定义一个字符串变量用于存储目前的输入，以及一个布尔变量用于标记是否已经输入过小数点。在每次用户点击数字或运算符Button时，将对应的字符添加到输入字符串中，并更新TextView上的显示内容。

3. 当用户点击小数点Button时，先检查是否已经输入过小数点，如果是，则不做任何操作，如果否，则在输入字符串中添加小数点，并将小数点标记设置为true。

4. 当用户点击运算符Button时，先将当前的输入字符串转换为数字，并根据当前的运算符和上一次输入的数字进行计算，最后将计算结果存储到输入字符串中，并清空标记小数点的变量。

5. 当用户点击等号Button时，执行最后一次运算，并将结果显示在TextView上。

6. 如果用户输入多个零，只显示一个零，可以在添加数字到输入字符串时，先判断输入的数字是否为零，如果是，则检查当前输入字符串的最后一个字符是否为零或小数点，如果是，则不做任何操作，否则将零添加到输入字符串中。

以上就是制作一个没有优先级，输入多个零只显示一个的多运算计算器的步骤。

相关问题

在android studio制作一个没有优先级，运算结果保留两位小数的计算器代码

### 回答1：
下面是一个简单的 Android Studio 计算器应用程序示例，它可以进行基本的加、减、乘、除运算，并且结果保留两位小数。

首先，在 activity_main.xml 中创建一个布局，包含 TextView、EditText 和 Button 元素：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/result_text_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:gravity="right"
        android:text="0"
        android:layout_marginTop="16dp"
        android:layout_marginBottom="16dp"
        android:layout_marginLeft="16dp"
        android:layout_marginRight="16dp"/>

    <EditText
        android:id="@+id/input_edit_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:gravity="right"
        android:hint="Enter a number"
        android:layout_below="@id/result_text_view"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="16dp"
        android:layout_marginRight="16dp"/>

    <Button
        android:id="@+id/button_add"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="+"
        android:textSize="24sp"
        android:layout_below="@id/input_edit_text"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="16dp"
        android:layout_marginRight="8dp"
        android:layout_alignParentLeft="true"
        android:layout_toLeftOf="@+id/button_subtract"/>

    <Button
        android:id="@+id/button_subtract"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="-"
        android:textSize="24sp"
        android:layout_below="@id/input_edit_text"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="16dp"
        android:layout_alignParentRight="true"/>

    <Button
        android:id="@+id/button_multiply"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="*"
        android:textSize="24sp"
        android:layout_below="@id/button_add"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="16dp"
        android:layout_marginRight="8dp"
        android:layout_alignParentLeft="true"
        android:layout_toLeftOf="@+id/button_divide"/>

    <Button
        android:id="@+id/button_divide"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="/"
        android:textSize="24sp"
        android:layout_below="@id/button_add"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="16dp"
        android:layout_alignParentRight="true"/>

    <Button
        android:id="@+id/button_clear"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="C"
        android:textSize="24sp"
        android:layout_below="@id/button_multiply"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="16dp"
        android:layout_marginRight="8dp"
        android:layout_alignParentLeft="true"
        android:layout_toLeftOf="@+id/button_equals"/>

    <Button
        android:id="@+id/button_equals"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="="
        android:textSize="24sp"
        android:layout_below="@id/button_divide"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="16dp"
        android:layout_alignParentRight="true"/>

</RelativeLayout>

接下来，在 MainActivity.java 中添加以下代码：

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;

import java.text.DecimalFormat;

public class MainActivity extends AppCompatActivity {

    private TextView resultTextView;
    private EditText inputEditText;

    private String currentNumber = "";
    private String lastOperation = "";
    private double result = 0.0;

    private DecimalFormat decimalFormat = new DecimalFormat("#.##");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        resultTextView = findViewById(R.id.result_text_view);
        inputEditText = findViewById(R.id.input_edit_text);

        Button buttonAdd = findViewById(R.id.button_add);
        Button buttonSubtract = findViewById(R.id.button_subtract);
        Button buttonMultiply = findViewById(R.id.button_multiply);
        Button buttonDivide = findViewById(R.id.button_divide);
        Button buttonClear = findViewById(R.id.button_clear);
        Button buttonEquals = findViewById(R.id.button_equals);

        buttonAdd.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                performOperation("+");
            }
        });

        buttonSubtract.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                performOperation("-");
            }
        });

        buttonMultiply.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                performOperation("*");
            }
        });

        buttonDivide.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                performOperation("/");
            }
        });

        buttonClear.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                currentNumber = "";
                lastOperation = "";
                result = 0.0;
                resultTextView.setText("0");
                inputEditText.setText("");
            }
        });

        buttonEquals.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                performOperation("");
            }
        });
    }

    private void performOperation(String operation) {
        if (!currentNumber.isEmpty()) {
            double number = Double.parseDouble(currentNumber);
            if (lastOperation.equals("+")) {
                result += number;
            } else if (lastOperation.equals("-")) {
                result -= number;
            } else if (lastOperation.equals("*")) {
                result *= number;
            } else if (lastOperation.equals("/")) {
                result /= number;
            } else {
                result = number;
            }
            currentNumber = "";
            resultTextView.setText(decimalFormat.format(result));
        }
        if (!operation.isEmpty()) {
            lastOperation = operation;
        }
    }

    public void onNumberButtonClick(View view) {
        Button button = (Button) view;
        String number = button.getText().toString();
        currentNumber += number;
        inputEditText.setText(currentNumber);
    }
}

这段代码实现了基本的计算器逻辑，包括处理加、减、乘、除和等于操作，并将结果显示在 TextView 中。它还包括清除操作和在 EditText 中输入数字的功能。

最后，运行该应用程序并测试它是否按预期工作。

### 回答2：
在Android Studio制作一个没有优先级，运算结果保留两位小数的计算器代码，我们可以按照以下步骤进行实现：

第一步，创建一个新的Android项目并打开Android Studio。

第二步，打开activity_main.xml文件，在布局中添加一个EditText用于显示计算结果，并添加多个Button用于输入数字和运算符。

第三步，打开MainActivity.java文件，创建所有Button的点击监听器，并在监听器中实现对应的逻辑。

在点击数字按钮时，将按钮的文本追加到EditText的末尾，以实现输入数字的功能。

在点击运算符按钮时，将按钮的文本添加到EditText的末尾，并在之后添加相应的运算符。

在点击等号按钮时，通过将EditText的文本转换为字符串，使用JavaScript引擎计算运算式的结果，并将结果保留两位小数后显示在EditText中。

在点击清除按钮时，清空EditText的内容，重新开始计算。

最后，确保在AndroidManifest.xml文件中声明MainActivity作为应用的主要活动。

这样，我们就成功地创建了一个没有优先级，运算结果保留两位小数的计算器应用。记得进行适当的布局和UI美化，使应用界面更加友好和易于使用。

### 回答3：
在Android Studio中制作一个没有优先级的计算器，运算结果保留两位小数的代码可以按以下步骤进行：

1. 首先，在布局文件中设计一个简单的计算器界面，包括数字按钮、运算符按钮和显示结果的TextView组件。

2. 在Activity中获取界面中的所有按钮和TextView的实例，并设置点击事件监听器。

3. 创建一个StringBuilder对象，用于存储用户输入的算式。

4. 在数字按钮的点击事件监听器中，将用户点击的数字追加到StringBuilder对象中，并更新显示结果的TextView。

5. 在运算符按钮的点击事件监听器中，将用户点击的运算符追加到StringBuilder对象中，并更新显示结果的TextView。

6. 在等号按钮的点击事件监听器中，获取StringBuilder对象中的算式，并使用JavaScript的eval()函数进行计算，得到结果。

7. 将计算结果保留两位小数，并更新显示结果的TextView。

以下是示例代码：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private TextView resultTextView;
    private StringBuilder equationBuilder;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        equationBuilder = new StringBuilder();
        resultTextView = findViewById(R.id.result_textView);

        // 获取数字按钮的实例，并设置点击事件监听器
        findViewById(R.id.button_0).setOnClickListener(this);
        findViewById(R.id.button_1).setOnClickListener(this);
        // ... 其他数字按钮

        // 获取运算符按钮的实例，并设置点击事件监听器
        findViewById(R.id.button_add).setOnClickListener(this);
        findViewById(R.id.button_subtract).setOnClickListener(this);
        // ... 其他运算符按钮

        // 获取等号按钮的实例，并设置点击事件监听器
        findViewById(R.id.button_equals).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button_0:
                equationBuilder.append("0");
                break;
            case R.id.button_1:
                equationBuilder.append("1");
                break;
            // ... 其他数字按钮

            case R.id.button_add:
                equationBuilder.append("+");
                break;
            case R.id.button_subtract:
                equationBuilder.append("-");
                break;
            // ... 其他运算符按钮

            case R.id.button_equals:
                String equation = equationBuilder.toString();
                double result = eval(equation);
                String resultString = String.format("%.2f", result);
                resultTextView.setText(resultString);
                break;
        }
    }

    // 使用JavaScript的eval()函数进行计算
    public static double eval(final String str) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < str.length()) ? str.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ')
                    nextChar();
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                return x;
            }

            double parseExpression() {
                double x = parseTerm();
                for (;;) {
                    if (eat('+'))
                        x += parseTerm(); // addition
                    else if (eat('-'))
                        x -= parseTerm(); // subtraction
                    else
                        return x;
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (;;) {
                    if (eat('*'))
                        x *= parseFactor(); // multiplication
                    else if (eat('/'))
                        x /= parseFactor(); // division
                    else
                        return x;
                }
            }

            double parseFactor() {
                if (eat('+'))
                    return parseFactor(); // unary plus
                if (eat('-'))
                    return -parseFactor(); // unary minus

                double x;
                int startPos = this.pos;
                if (eat('(')) { // parentheses
                    x = parseExpression();
                    eat(')');
                } else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers
                    while ((ch >= '0' && ch <= '9') || ch == '.')
                        nextChar();
                    x = Double.parseDouble(str.substring(startPos, this.pos));
                } else {
                    throw new RuntimeException("Invalid expression");
                }

                return x;
            }
        }.parse();
    }
}

以上代码实现了一个简单的计算器，在计算过程中没有优先级，最终结果会保留两位小数，并显示在界面上的TextView中。

在android studio中制作一个没有优先级，运行结果保留两位小数的多位数相加减的计算器

以下是一个简单的 Android Studio 计算器代码，支持多位数相加减运算，没有优先级，运行结果保留两位小数：

1. 创建一个新的 Android Studio 项目，并在 `activity_main.xml` 中添加一个输入框、一个文本框和四个按钮，分别用于输入数字、显示结果和执行加减运算。

   <EditText
       android:id="@+id/etInput"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="请输入数字" />

   <TextView
       android:id="@+id/tvResult"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:text="结果：0.00"
       android:textAlignment="center"
       android:textSize="24sp" />

   <Button
       android:id="@+id/btnAdd"
       android:layout_width="0dp"
       android:layout_height="wrap_content"
       android:layout_weight="1"
       android:text="+" />

   <Button
       android:id="@+id/btnSubtract"
       android:layout_width="0dp"
       android:layout_height="wrap_content"
       android:layout_weight="1"
       android:text="-" />

   <Button
       android:id="@+id/btnClear"
       android:layout_width="0dp"
       android:layout_height="wrap_content"
       android:layout_weight="1"
       android:text="清空" />

   <Button
       android:id="@+id/btnCalculate"
       android:layout_width="0dp"
       android:layout_height="wrap_content"
       android:layout_weight="1"
       android:text="计算" />

2. 在 `MainActivity.java` 中添加以下代码：

   public class MainActivity extends AppCompatActivity {
       private EditText etInput;
       private TextView tvResult;
       private Button btnAdd, btnSubtract, btnClear, btnCalculate;
       private double result = 0;

       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);

           etInput = findViewById(R.id.etInput);
           tvResult = findViewById(R.id.tvResult);
           btnAdd = findViewById(R.id.btnAdd);
           btnSubtract = findViewById(R.id.btnSubtract);
           btnClear = findViewById(R.id.btnClear);
           btnCalculate = findViewById(R.id.btnCalculate);

           btnAdd.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   try {
                       double num = Double.parseDouble(etInput.getText().toString());
                       result += num;
                       tvResult.setText(String.format("结果：%.2f", result));
                       etInput.setText("");
                   } catch (NumberFormatException e) {
                       Toast.makeText(MainActivity.this, "请输入有效数字", Toast.LENGTH_SHORT).show();
                   }
               }
           });

           btnSubtract.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   try {
                       double num = Double.parseDouble(etInput.getText().toString());
                       result -= num;
                       tvResult.setText(String.format("结果：%.2f", result));
                       etInput.setText("");
                   } catch (NumberFormatException e) {
                       Toast.makeText(MainActivity.this, "请输入有效数字", Toast.LENGTH_SHORT).show();
                   }
               }
           });

           btnClear.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   result = 0;
                   tvResult.setText("结果：0.00");
                   etInput.setText("");
               }
           });

           btnCalculate.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   try {
                       double num = Double.parseDouble(etInput.getText().toString());
                       result += num;
                       tvResult.setText(String.format("结果：%.2f", result));
                       etInput.setText("");
                   } catch (NumberFormatException e) {
                       Toast.makeText(MainActivity.this, "请输入有效数字", Toast.LENGTH_SHORT).show();
                   }
               }
           });
       }
   }

代码思路：

1. 在 `onCreate` 方法中，使用 `findViewById` 方法来获取输入框、文本框和四个按钮的实例。
2. 为加、减、清空和计算按钮分别添加点击事件监听器。
3. 在点击事件监听器中，使用 `Double.parseDouble` 方法将输入框中的字符串转换为 double 类型的数字，然后进行加减运算，并使用 `String.format` 方法将结果格式化成保留两位小数的字符串，最后显示在文本框中。
4. 如果输入的字符串无法转换为有效的数字，则弹出一个提示框。