Android / Java-将int值从方程式转换为double
[英]Android/Java - Convert int values from a equation to double
问题描述
I'm creating a calculator app which works showing all the calculation steps in the screen, like this: 
我正在创建一个计算器应用程序，该应用程序可以在屏幕上显示所有计算步骤，如下所示：
3x3x5/7*(3/2) 3x3x5 / 7 *（3/2）
And then, the user just click in the "Enter" button to get the result. 然后，用户只需单击“ Enter”按钮即可获得结果。
The problem is that I'm always getting a integer value as a result, which is obvious, because I'm using integer values in the calculation (3, 5, 7, etc). 问题是我总是得到一个整数值，这很明显，因为我在计算中使用了整数值（3、5、7等）。 So, if I do this: 1/2, the result will be 0, but I want the answer to be 0.5 因此，如果我这样做：1/2，结果将为0，但我希望答案为0.5
To be more specifcaly, this is how my calculator works: The user hit the button 5, and it appears in the screen (a textview). 更具体地说，这就是我的计算器的工作方式：用户按下按钮5，它出现在屏幕上（文本视图）。 Then the user hit the button / (divide), using the append method, the screen now shows 5/, finaly the user hit the button 9, and the screen shows 5/9. 然后，用户使用append方法按下按钮/（除法），屏幕现在显示5 /，最后用户按下按钮9，屏幕显示5/9。
When the user hit "Enter", the app get the text from the screen and store it in a String variable, which will be used by the JEXL library (used to evaluate equations), giving me the result. 当用户按下“ Enter”键时，应用程序会从屏幕上获取文本并将其存储在String变量中，该变量将由JEXL库（用于评估方程式）使用，从而为我提供结果。
The problem is that, I want the numbers to appear in the screen as integer, so if I hit 9, I don't want it to appears as 9.0 in the screen, but there's another problem, imagine that I want to enter the number "93", I would firts hit 9, and 9.0 would appear, then I would hit 3, and 3.0 would appear, giving me the "number" 9.03.0, which don't exist and can't be used. 问题是，我希望数字在屏幕上显示为整数，所以如果我打9，我不希望它在屏幕上显示为9.0，但是还有另一个问题，假设我想输入数字“ 93”，我将命中9，然后出现9.0，然后我将击中3，然后出现3.0，为我提供“数字” 9.03.0，该数字不存在并且无法使用。
So, where's a way to convert integer numbers in a String expression to double? 那么，将String表达式中的整数转换为double的方法是什么？ Or, maybe, to get a double value from a integer calculation? 或者，也许要从整数计算中获得双精度值？
Here's my java files: 这是我的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()));
}
}
}
And this one too, but isn't being used so far: 这也是，但到目前为止尚未使用：
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;
}
}
}
}
Well, the solution that I found is this: 好吧，我找到的解决方案是这样的：
if (operators.contains(buttonPressed)) {
tempNumber = Double.parseDouble(tv_screen.getText().toString().replace(tempString, ""));
equation = equation + tempNumber.toString() + buttonPressed;
tempString = tv_screen.getText().toString() + buttonPressed;
}
I created 3 variables: Double tempNumber, which will get the values from the screen and store it as double. 我创建了3个变量：Double tempNumber，它将从屏幕上获取值并将其存储为double。 String equation, which will store the equation as String with Double values, so, "9*3" will be "9.0*3.0". 字符串方程式，它将方程式存储为具有Double值的字符串，因此，“ 9 * 3”将为“ 9.0 * 3.0”。 String tempString, which is used to "clean" the tempNumber variable, replacing the "x", "/", and so on, with "" (nothing), so it'll convert only numbers to double. 字符串tempString，用于“清理” tempNumber变量，将“ x”，“ /”等替换为“”（什么都没有），因此它将仅将数字转换为双精度。
Finaly, I'll instead of getting the equation from the screen textview, I'll get it from the equation variable: 最后，我将不再从屏幕文本视图中获取方程式，而是将其从方程式变量中获取：
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();
Anyway, thank you everyone for your time! 无论如何，谢谢大家的宝贵时间！
3 个解决方案
解决方案1
4 已采纳 2014-01-06 16:49:45
If you want to parse the double from a string you can use 如果要从字符串中解析双精度，则可以使用
Double.parseDouble(sValue);
You can also use an explisit conversion in line for your equation so you can do something like: 您还可以在表达式中直接使用explisit转换，因此您可以执行以下操作：
(double)inum*(double)inum1*(double)inum2/(double)inum4*((double)inum5/(double)inum6)
and your result should then come out as a double instead of an integer. 然后您的结果应为双精度而不是整数。
解决方案2
0 2014-01-06 16:47:46
It will help if all your numbers are of type double, especially your answer. 如果您所有的数字都是双精度类型，特别是您的答案，这将有所帮助。 to force a double as your answer, use typecasting or multiply by 1.0 when doing division and multiplication. 要强制使用双精度字作为答案，请在进行除法和乘法时使用类型转换或乘以1.0。 (literally "1.0", not just "1") （字面意思是“ 1.0”，而不仅仅是“ 1”）
解决方案3
-1 2014-01-06 16:53:12
Java by default supports integer arithmetic. Java默认情况下支持整数算术。 To get the result in float or double(decimal point values),we should perform operation on the float or double data type. 要获得float或double（小数点值）的结果，我们应该对float或double数据类型执行操作。 for eg : 例如：
double x = 3.0/2.0
will give you x as 1.5 :) but, 将给您x为1.5 :)但是，
double x = 3/2
will give you 1 ,which you won't prefer in this case :( Hope,this helps you 会给您1 ，在这种情况下，您将不会选择它：(希望，这对您有帮助
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.