我正在创建一个计算器应用程序，它可以显示屏幕上的所有计算步骤，如下所示：
3x3x5 / 7 *（3/2）
然后，用户只需单击“Enter”按钮即可获得结果。
问题是我总是得到一个整数值，这很明显，因为我在计算中使用整数值（3,5,7等）。 所以，如果我这样做：1/2，结果将为0，但我希望答案为0.5
更具体地说，这是我的计算器的工作方式：
用户点击按钮5，它出现在屏幕上（文本视图）。
然后用户点击按钮/（除），使用追加方法，屏幕现在显示5 /，最后用户按下按钮9，屏幕显示5/9。
当用户点击“Enter”时，应用程序从屏幕获取文本并将其存储在String变量中，该变量将由JEXL库（用于计算方程式）使用，从而为我提供结果。
问题是，我希望数字在屏幕上显示为整数，所以如果我点击9，我不希望它在屏幕上显示为9.0，但还有另一个问题，想象我想要输入数字“93”，我会先打9，然后会出现9.0，然后我会打3，然后会出现3.0，给我“数字”9.03.0，它不存在且无法使用
那么，在哪里可以将String表达式中的整数转换为double？ 或者，也许，从整数计算中得到一个双精度值？
这是我的java文件：
public class Main extends Activity implements OnClickListener {
TextView tv_screen;
TextView tv_set1;
TextView tv_set2;
String screenEvaluation;
Double screenCalculation;
JexlEngine jexl = new JexlEngine();
static final String digits = "0123456789.*/-+^( )√(";
static final String numbers = "0123456789";
static final String operators = "*/-+";
static final String shifteds = "B1";
Boolean shiftPressed = false;
Boolean userIsInTheMiddleOfTypingANumber = false;
Solver solver = new Solver();
DecimalFormat df = new DecimalFormat("@###########");
NumberFormat nf = new DecimalFormat("#.####");
//String buttonPressed;
@Override
protected void onCreate(Bundle savedInstanceState) {
/* REMOVE TITLE BAR */
this.requestWindowFeature(Window.FEATURE_NO_TITLE);
/* REMOVE NOTIFICATION BAR (AKA FULL SCREEN) */
this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
df.setMinimumFractionDigits(0);
df.setMinimumIntegerDigits(1);
df.setMaximumIntegerDigits(8);
tv_screen = (TextView) findViewById(R.id.tv_screen);
tv_set1 = (TextView) findViewById(R.id.tv_set1);
tv_set2 = (TextView) findViewById(R.id.tv_set2);
findViewById(R.id.button_1).setOnClickListener(this);
findViewById(R.id.button_2).setOnClickListener(this);
findViewById(R.id.button_3).setOnClickListener(this);
findViewById(R.id.button_4).setOnClickListener(this);
findViewById(R.id.button_5).setOnClickListener(this);
findViewById(R.id.button_6).setOnClickListener(this);
findViewById(R.id.button_7).setOnClickListener(this);
findViewById(R.id.button_8).setOnClickListener(this);
findViewById(R.id.button_9).setOnClickListener(this);
findViewById(R.id.button_0).setOnClickListener(this);
findViewById(R.id.button_multiply).setOnClickListener(this);
findViewById(R.id.button_divide).setOnClickListener(this);
findViewById(R.id.button_minus).setOnClickListener(this);
findViewById(R.id.button_sum).setOnClickListener(this);
findViewById(R.id.button_root).setOnClickListener(this);
findViewById(R.id.button_power).setOnClickListener(this);
findViewById(R.id.button_bracket).setOnClickListener(this);
findViewById(R.id.button_more_less).setOnClickListener(this);
findViewById(R.id.button_dot).setOnClickListener(this);
findViewById(R.id.button_shift).setOnClickListener(this);
findViewById(R.id.button_enter).setOnClickListener(this);
findViewById(R.id.button_clear).setOnClickListener(this);
}
@Override
public void onClick(View v) {
String buttonPressed = ((Button) v).getText().toString();
if (digits.contains(buttonPressed)) {
// digit was pressed
if (userIsInTheMiddleOfTypingANumber) {
if (buttonPressed.equals(".") && tv_screen.getText().toString().contains(".")) {
// ERROR PREVENTION
// Eliminate entering multiple decimals
} else {
if (buttonPressed.equals("( )")) {
buttonPressed = "(";
if (tv_screen.getText().toString().contains("(")) {
buttonPressed = ")";
}
}
if (buttonPressed.equals("√")) {
buttonPressed = "√(";
}
if (operators.contains(buttonPressed)) {
tv_screen.append(".0" + buttonPressed);
} else {
tv_screen.append(buttonPressed);
}
}
} else {
if (buttonPressed.equals(".")) {
// ERROR PREVENTION
// This will avoid error if only the decimal is hit before an operator, by placing a leading zero
// before the decimal
tv_screen.setText(0 + buttonPressed);
} else {
if (buttonPressed.equals("( )")) {
buttonPressed = "(";
if (tv_screen.getText().toString().contains("(")) {
buttonPressed = ")";
}
}
if (buttonPressed.equals("√")) {
buttonPressed = "√(";
}
tv_screen.setText(buttonPressed);
}
userIsInTheMiddleOfTypingANumber = true;
}
} else if (buttonPressed.equals("SHIFT")) {
if (shiftPressed == true) {
shiftPressed = false;
solver.setShift(false);
tv_set1.setText("");
} else {
shiftPressed = true;
solver.setShift(true);
tv_set1.setText("SHIFT");
}
} else if (buttonPressed.equals("ENTER")) {
//solver.performEnterOperation(buttonPressed);
//tv_screen.setText("DONE!");
screenEvaluation = tv_screen.getText().toString();
//screenEvaluation = screenEvaluation.replace("x", "*");
screenEvaluation = screenEvaluation.replace("√(", "SQRT(");
Log.w("TAG", "thickness round:" + screenEvaluation);
Expression e = jexl.createExpression(screenEvaluation);
JexlContext context = new MapContext();
String result = e.evaluate(context).toString();
//Log.w("TAG", "thickness round:" + screenEvaluation);
tv_screen.setText(result);
userIsInTheMiddleOfTypingANumber = false;
} else if (shifteds.contains(buttonPressed) && shiftPressed == true) {
tv_set2.setText(solver.getSetTextView(buttonPressed));
} else if (buttonPressed.equals("CLEAR")) {
userIsInTheMiddleOfTypingANumber = false;
tv_screen.setText("0");
} else {
// operation was pressed
if (userIsInTheMiddleOfTypingANumber) {
//Log.w("TAG", "thickness round:" + yyy);
tv_set2.setText(solver.getSetTextView(buttonPressed));
solver.setOperand(Double.parseDouble(tv_screen.getText().toString()));
userIsInTheMiddleOfTypingANumber = false;
}
//tv_set2.setText(solver.getSetTextView(buttonPressed));
solver.performOperation(buttonPressed);
tv_screen.setText(df.format(solver.getResult()));
}
}
}
也是这个，但到目前为止还没有被使用：
public class Solver {
// 3 + 6 = 9
// 3 & 6 are called the operand.
// The + is called the operator.
// 9 is the result of the operation.
private double mOperand;
private double mWaitingOperand;
private String mWaitingOperator;
private double mCalculatorMemory;
private Boolean shift;
private double pressure;
private double inner_diameter;
private double allowable_stress;
private double weld_factor;
private double y_factor;
private double corrosion;
// operator types
public static final String ADD = "+";
public static final String SUBTRACT = "-";
public static final String MULTIPLY = "x";
public static final String DIVIDE = "/";
public static final String CLEAR = "C" ;
public static final String CLEARMEMORY = "MC";
public static final String ADDTOMEMORY = "M+";
public static final String SUBTRACTFROMMEMORY = "M-";
public static final String RECALLMEMORY = "MR";
public static final String SQUAREROOT = "√";
public static final String SQUARED = "x²";
public static final String INVERT = "1/x";
public static final String TOGGLESIGN = "+/-";
public static final String SINE = "sin";
public static final String COSINE = "cos";
public static final String TANGENT = "tan";
public static final String ARC = "ARC";
public static final String B1 = "B1";
public static final String B2 = "B2";
public static final String B3 = "B3";
public static final String B4 = "B4";
public static final String B5 = "B5";
public static final String B6 = "B6";
// public static final String EQUALS = "=";
// constructor
public Solver() {
// initialize variables upon start
mOperand = 0;
mWaitingOperand = 0;
mWaitingOperator = "";
mCalculatorMemory = 0;
shift = false;
pressure = 0;
inner_diameter = 0;
allowable_stress = 0;
weld_factor = 0;
y_factor = 0;
corrosion = 0;
}
public void setOperand(double operand) {
mOperand = operand;
}
public double getResult() {
return mOperand;
}
// used on screen orientation change
public void setMemory(double calculatorMemory) {
mCalculatorMemory = calculatorMemory;
}
// used on screen orientation change
public double getMemory() {
return mCalculatorMemory;
}
public String toString() {
return Double.toString(mOperand);
}
public void setShift(Boolean shiftState) {
shift = shiftState;
}
public void setPressure(double setPressure) {
pressure = setPressure;
}
public void setInnerDiameter(double setInnerDiameter) {
inner_diameter = setInnerDiameter;
}
public void setAllowableStress(double setAllowableStress) {
allowable_stress = setAllowableStress;
}
public void setWeldFactor(double setWeldFactor) {
weld_factor = setWeldFactor;
}
public void setYFactor(double setYFactor) {
y_factor = setYFactor;
}
public void setCorrosion(double setCorrosion) {
corrosion = setCorrosion;
}
public String getSetTextView(String setText) {
String text;
if (setText.equals(ARC)) {
text = "PIPE";
return text;
} else if (setText.equals(B1)) {
text = "PRESSURE";
return text;
} else if (setText.equals(B2)) {
text = "INNER DIAMETER";
return text;
} else if (setText.equals(B3)) {
text = "ALLOWABLE STRESS";
return text;
} else if (setText.equals(B4)) {
text = "WELD FACTOR";
return text;
} else if (setText.equals(B5)) {
text = "Y FACTOR";
return text;
} else if (setText.equals(B6)) {
text = "CORROSION";
return text;
}
text = "NADA";
return text;
}
public double pipeThickness(double inner_pressure, double allowable_stress, double weld_factor, double inner_diameter, double corrosion, double y_factor) {
double thickness = ( ( inner_pressure * inner_diameter) + ( 2* allowable_stress * weld_factor * corrosion )
+ ( 2 * y_factor * inner_pressure * corrosion ) ) / ( 2* ( ( allowable_stress * weld_factor )
+ ( inner_pressure * y_factor ) - inner_pressure ) );
return thickness;
}
protected void performEnterOperation(String operator) {
if (shift == true) {
if (operator.equals(B1)) {
setPressure(mOperand);
}
}
}
protected double performOperation(String operator) {
/*
* If you are using Java 7, then you can use switch in place of if statements
*
* switch (operator) {
* case CLEARMEMORY:
* calculatorMemory = 0;
* break;
* case ADDTOMEMORY:
* calculatorMemory = calculatorMemory + operand;
* break;
* etc...
* }
*/
if (shift == true) {
if (operator.equals(ARC)) {
getSetTextView(ARC);
mOperand = 25.0;
}
} else {
if (operator.equals(CLEAR)) {
mOperand = 0;
mWaitingOperator = "";
mWaitingOperand = 0;
// mCalculatorMemory = 0;
} else if (operator.equals(CLEARMEMORY)) {
mCalculatorMemory = 0;
} else if (operator.equals(ADDTOMEMORY)) {
mCalculatorMemory = mCalculatorMemory + mOperand;
} else if (operator.equals(SUBTRACTFROMMEMORY)) {
mCalculatorMemory = mCalculatorMemory - mOperand;
} else if (operator.equals(RECALLMEMORY)) {
mOperand = mCalculatorMemory;
} else if (operator.equals(SQUAREROOT)) {
mOperand = Math.sqrt(mOperand);
} else if (operator.equals(SQUARED)) {
mOperand = mOperand * mOperand;
} else if (operator.equals(INVERT)) {
if (mOperand != 0) {
mOperand = 1 / mOperand;
}
} else if (operator.equals(TOGGLESIGN)) {
mOperand = -mOperand;
} else if (operator.equals(SINE)) {
mOperand = Math.sin(Math.toRadians(mOperand)); // Math.toRadians(mOperand) converts result to degrees
} else if (operator.equals(COSINE)) {
mOperand = Math.cos(Math.toRadians(mOperand)); // Math.toRadians(mOperand) converts result to degrees
} else if (operator.equals(TANGENT)) {
mOperand = Math.tan(Math.toRadians(mOperand)); // Math.toRadians(mOperand) converts result to degrees
} else {
performWaitingOperation();
mWaitingOperator = operator;
mWaitingOperand = mOperand;
}
}
return mOperand;
}
protected void performWaitingOperation() {
if (mWaitingOperator.equals(ADD)) {
mOperand = mWaitingOperand + mOperand;
} else if (mWaitingOperator.equals(SUBTRACT)) {
mOperand = mWaitingOperand - mOperand;
} else if (mWaitingOperator.equals(MULTIPLY)) {
mOperand = mWaitingOperand * mOperand;
} else if (mWaitingOperator.equals(DIVIDE)) {
if (mOperand != 0) {
mOperand = mWaitingOperand / mOperand;
}
}
}
}
嗯，我找到的解决方案是：
if (operators.contains(buttonPressed)) {
tempNumber = Double.parseDouble(tv_screen.getText().toString().replace(tempString, ""));
equation = equation + tempNumber.toString() + buttonPressed;
tempString = tv_screen.getText().toString() + buttonPressed;
}
我创建了3个变量： double tempNumber，它将从屏幕获取值并将其存储为double。 字符串方程式，它将方程式存储为具有Double值的String，因此，“9 * 3”将为“9.0 * 3.0”。 字符串tempString，用于“清理”tempNumber变量，将“x”，“/”等替换为“”（无），因此它只会将数字转换为double。
最后，我不会从屏幕文本视图中获取等式，我将从等式变量中得到它：
tempNumber = Double.parseDouble(tv_screen.getText().toString().replace(tempString, ""));
equation = equation + tempNumber.toString();
Expression e = jexl.createExpression(equation);
JexlContext context = new MapContext();
String result = e.evaluate(context).toString();
无论如何，谢谢大家的时间！
答案 0 :(得分：4)
如果要从字符串中解析double，可以使用
Double.parseDouble(sValue);
您也可以在等式中使用explisit转换，这样您就可以执行以下操作：
(double)inum*(double)inum1*(double)inum2/(double)inum4*((double)inum5/(double)inum6)
然后你的结果应该是一个double而不是一个整数。
答案 1 :(得分：0)
如果您的所有数字都是double类型，尤其是您的答案，这将有所帮助。强制使用双精度作为答案，使用类型转换或在进行除法和乘法时乘以1.0。 （字面意思是＆＃34; 1.0＆＃34;，而不仅仅是＆＃34; 1＆＃34;）
答案 2 :(得分：-1)
Java默认支持整数运算。 要使结果为float或double（小数点值），我们应该对float或double数据类型执行操作。 例如：
double x = 3.0/2.0
会给你x 1.5 :) 但是，
double x = 3/2
会给你 1 ，在这种情况下你不会喜欢:( 希望，这有助于你