http://blog.csdn.net/huangyanbin123/article/details/38943575

上个星期的时候，我想教我朋友做一个简单的app。想来想去教什么比较好，当时看见小米的计算器觉得比较漂亮，就想这个简单！然后就开始动手做了。我以为可以一个小时可以搞定，没想到花了快一天的时间。哎！突然想起以前公司的CTO的话，一切都是从简单开始的。

       我自己的思路是：将计算器的item分为：integer，float，运算符，用list去存储。然后我通过标记上一次输入的标记，判断它是否该插入list还是拿到last修改。然后根据先遍历高级运算，得到结果，将i-1设置为得到的结果，移除i+1,i。再遍历低级运算，最后得到list(0)就是所需要的结果。当然，肯定需要很多判断之类，因为demo的原因，我没有再去改善它。因为这个毕竟是我个人思路，如果有哪位朋友有更好的想法，可以给我留言。

1.输入的model

[java]  view plain copy

1. package com.example.calculator;  
2.   
3. public class InputItem {  
4.       
5.     private String input;  
6.     private int type;  
7.       
8.       
9.       
10.     public InputItem() {  
11.         super();  
12.     }  
13.     public InputItem(String input, int type) {  
14.         super();  
15.         this.input = input;  
16.         this.type = type;  
17.     }  
18.     public String getInput() {  
19.         return input;  
20.     }  
21.     public void setInput(String input) {  
22.         this.input = input;  
23.     }  
24.     public int getType() {  
25.         return type;  
26.     }  
27.     public void setType(int type) {  
28.         this.type = type;  
29.     }  
30.       
31.     interface InputType {  
32.         public static final int INT_TYPE = 0; //int 类型  
33.         public static final int DOUBLE_TYPE=1; //double 类型  
34.         public static final int OPERATOR_TYPE = 2; //操作符类型  
35.         public static final int ERROR = 3; //操作符类型  
36.     }  
37.   
38.     @Override  
39.     public String toString() {  
40.         return "InputItem [input=" + input + ", type=" + type + "]";  
41.     }  
42.       
43.   
44. }  

2.逻辑运算

[java]  view plain copy

1. package com.example.calculator;  
2.   
3. import java.math.BigDecimal;  
4. import java.util.ArrayList;  
5. import java.util.HashMap;  
6. import java.util.List;  
7.   
8. import com.example.calculator.InputItem.InputType;  
9.   
10. import android.os.Bundle;  
11. import android.os.Handler;  
12. import android.os.Message;  
13. import android.annotation.SuppressLint;  
14. import android.app.Activity;  
15.   
16. import android.view.View;  
17. import android.view.View.OnClickListener;  
18. import android.view.animation.Animation;  
19. import android.view.animation.AnimationUtils;  
20. import android.widget.Button;  
21. import android.widget.TextView;  
22.   
23. public class MainActivity extends Activity implements OnClickListener{  
24.       
25.     private TextView mShowResultTv;  //显示结果  
26.     private TextView mShowInputTv;   //显示输入的字符  
27.     private Button mCBtn;  
28.     private Button mDelBtn;  
29.     private Button mAddBtn;  
30.     private Button mSubBtn;  
31.     private Button mMultiplyBtn;  
32.     private Button mDividebtn;  
33.     private Button mZeroButton;  
34.     private Button mOnebtn;  
35.     private Button mTwoBtn;  
36.     private Button mThreeBtn;  
37.     private Button mFourBtn;  
38.     private Button mFiveBtn;  
39.     private Button mSixBtn;  
40.     private Button mSevenBtn;  
41.     private Button mEightBtn;  
42.     private Button mNineBtn;  
43.     private Button mPointtn;  
44.     private Button mEqualBtn;  
45.     private HashMap<View,String> map; //将View和String映射起来   
46.     private List<InputItem> mInputList; //定义记录每次输入的数  
47.     private int mLastInputstatus = INPUT_NUMBER; //记录上一次输入状态  
48.     public static final int INPUT_NUMBER = 1;   
49.     public static final int INPUT_POINT = 0;  
50.     public static final int INPUT_OPERATOR = -1;  
51.     public static final int END = -2;  
52.     public static final int ERROR= -3;  
53.     public static final int SHOW_RESULT_DATA = 1;  
54.     public static final String nan = "NaN";  
55.     public static final String infinite = "∞";  
56.       
57.     @SuppressLint("HandlerLeak")  
58.     private Handler mHandler = new Handler(){  
59.   
60.         public void handleMessage(Message msg) {  
61.               
62.             if(msg.what == SHOW_RESULT_DATA){  
63.                 mShowResultTv.setText(mShowInputTv.getText());  
64.                 mShowInputTv.setText(mInputList.get(0).getInput());  
65.                 clearScreen(mInputList.get(0));  
66.             }  
67.         }  
68.     };  
69.   
70.   
71.     @Override  
72.     protected void onCreate(Bundle savedInstanceState) {  
73.         super.onCreate(savedInstanceState);  
74.         setContentView(R.layout.activity_main);  
75.         initView();   
76.         initData();   
77.     }  
78.     /** 
79.      * 初始化view 
80.      */  
81.     private void initView() {  
82.         mShowResultTv = (TextView) this.findViewById(R.id.show_result_tv);  
83.         mShowInputTv = (TextView)this.findViewById(R.id.show_input_tv);  
84.         mCBtn = (Button)this.findViewById(R.id.c_btn);  
85.         mDelBtn= (Button)this.findViewById(R.id.del_btn);  
86.         mAddBtn= (Button)this.findViewById(R.id.add_btn);  
87.         mMultiplyBtn= (Button)this.findViewById(R.id.multiply_btn);  
88.         mDividebtn= (Button)this.findViewById(R.id.divide_btn);  
89.         mZeroButton = (Button)this.findViewById(R.id.zero_btn);  
90.         mOnebtn= (Button)this.findViewById(R.id.one_btn);  
91.         mTwoBtn= (Button)this.findViewById(R.id.two_btn);  
92.         mThreeBtn= (Button)this.findViewById(R.id.three_btn);  
93.         mFourBtn= (Button)this.findViewById(R.id.four_btn);  
94.         mFiveBtn= (Button)this.findViewById(R.id.five_btn);  
95.         mSixBtn= (Button)this.findViewById(R.id.six_btn);  
96.         mSevenBtn= (Button)this.findViewById(R.id.seven_btn);  
97.         mEightBtn= (Button)this.findViewById(R.id.eight_btn);  
98.         mNineBtn= (Button)this.findViewById(R.id.nine_btn);  
99.         mPointtn= (Button)this.findViewById(R.id.point_btn);  
100.         mEqualBtn= (Button)this.findViewById(R.id.equal_btn);  
101.         mSubBtn = (Button)this.findViewById(R.id.sub_btn);  
102.         setOnClickListener();//调用监听事件  
103.           
104.     }  
105.     /** 
106.      * 初始化数据 
107.      */  
108.     private void initData() {  
109.         if(map == null)  
110.             map = new HashMap<View, String>();  
111.         map.put(mAddBtn,getResources().getString(R.string.add));  
112.         map.put(mMultiplyBtn,getResources().getString(R.string.multply));  
113.         map.put(mDividebtn,getResources().getString(R.string.divide));  
114.         map.put(mSubBtn, getResources().getString(R.string.sub));  
115.         map.put(mZeroButton ,getResources().getString(R.string.zero));  
116.         map.put(mOnebtn,getResources().getString(R.string.one));  
117.         map.put(mTwoBtn,getResources().getString(R.string.two));  
118.         map.put(mThreeBtn,getResources().getString(R.string.three));  
119.         map.put(mFourBtn,getResources().getString(R.string.four));  
120.         map.put(mFiveBtn,getResources().getString(R.string.five));  
121.         map.put(mSixBtn,getResources().getString(R.string.six));  
122.         map.put(mSevenBtn,getResources().getString(R.string.seven));  
123.         map.put(mEightBtn,getResources().getString(R.string.eight));  
124.         map.put(mNineBtn,getResources().getString(R.string.nine));  
125.         map.put(mPointtn,getResources().getString(R.string.point));  
126.         map.put(mEqualBtn,getResources().getString(R.string.equal));  
127.         mInputList = new ArrayList<InputItem>();  
128.         mShowResultTv.setText("");  
129.         clearAllScreen();  
130.     }  
131.   
132.     /** 
133.      * 设置监听事件 
134.      */  
135.     private void setOnClickListener() {  
136.         mCBtn.setOnClickListener(this);  
137.         mDelBtn.setOnClickListener(this);  
138.         mAddBtn.setOnClickListener(this);  
139.         mMultiplyBtn.setOnClickListener(this);  
140.         mDividebtn.setOnClickListener(this);  
141.         mSubBtn.setOnClickListener(this);  
142.         mZeroButton.setOnClickListener(this);  
143.         mOnebtn.setOnClickListener(this);  
144.         mTwoBtn.setOnClickListener(this);  
145.         mThreeBtn.setOnClickListener(this);  
146.         mFourBtn.setOnClickListener(this);  
147.         mFiveBtn.setOnClickListener(this);  
148.         mSixBtn.setOnClickListener(this);  
149.         mSevenBtn.setOnClickListener(this);  
150.         mEightBtn.setOnClickListener(this);  
151.         mNineBtn.setOnClickListener(this);  
152.         mPointtn.setOnClickListener(this);  
153.         mEqualBtn.setOnClickListener(this);  
154.     }  
155.   
156.     /** 
157.      * 点击事件 
158.      */  
159.     @Override  
160.     public void onClick(View arg0) {  
161.         switch (arg0.getId()) {  
162.         case R.id.c_btn:  
163.             clearAllScreen();  
164.             break;  
165.         case R.id.del_btn:  
166.             back();  
167.             break;  
168.         case R.id.point_btn:  
169.             inputPoint(arg0);  
170.             break;  
171.         case R.id.equal_btn:  
172.             operator();  
173.             break;  
174.         case R.id.add_btn:  
175.         case R.id.sub_btn:  
176.         case R.id.multiply_btn:  
177.         case R.id.divide_btn:  
178.             inputOperator(arg0);  
179.             break;  
180.         default:  
181.             inputNumber(arg0);  
182.             break;  
183.         }  
184.     }  
185.     /** 
186.      * 点击=之后开始运算 
187.      */  
188.     private void operator() {  
189.         if(mLastInputstatus == END ||mLastInputstatus == ERROR || mLastInputstatus == INPUT_OPERATOR|| mInputList.size()==1){  
190.             return;  
191.         }  
192.         mShowResultTv.setText("");  
193.         startAnim();  
194.         findHighOperator(0);  
195.         if(mLastInputstatus != ERROR){  
196.             findLowOperator(0);  
197.         }  
198.         mHandler.sendMessageDelayed(mHandler.obtainMessage(SHOW_RESULT_DATA), 300);  
199.     }  
200.       
201.     private void startAnim(){  
202.         mShowInputTv.setText(mShowInputTv.getText()+getResources().getString(R.string.equal));  
203.         Animation anim = AnimationUtils.loadAnimation(this, R.anim.screen_anim);  
204.         mShowInputTv.startAnimation(anim);  
205.     }  
206.     /** 
207.      * 输入点 
208.      * @param view 
209.      */  
210.     private void inputPoint(View view) {  
211.         if(mLastInputstatus == INPUT_POINT){  
212.             return;  
213.         }  
214.         if(mLastInputstatus == END || mLastInputstatus == ERROR){  
215.             clearInputScreen();  
216.         }  
217.         String key = map.get(view);  
218.         String input = mShowInputTv.getText().toString();  
219.         if(mLastInputstatus == INPUT_OPERATOR){  
220.             input = input+"0";  
221.         }   
222.         mShowInputTv.setText(input+key);  
223.         addInputList(INPUT_POINT, key);  
224.     }  
225.     /** 
226.      * 输入数字 
227.      * @param view 
228.      */  
229.     private void inputNumber(View view){  
230.         if(mLastInputstatus == END || mLastInputstatus == ERROR){  
231.             clearInputScreen();  
232.         }  
233.         String key = map.get(view);  
234.         if("0".equals(mShowInputTv.getText().toString())){  
235.             mShowInputTv.setText(key);  
236.         }else{  
237.         mShowInputTv.setText(mShowInputTv.getText() + key);  
238.         }  
239.         addInputList(INPUT_NUMBER, key);  
240.     }  
241.     /** 
242.      * 输入运算符 
243.      * @param view 
244.      */  
245.     private void inputOperator(View view) {  
246.         if(mLastInputstatus == INPUT_OPERATOR || mLastInputstatus == ERROR){  
247.             return;  
248.         }  
249.         if(mLastInputstatus == END){  
250.             mLastInputstatus = INPUT_NUMBER;  
251.         }  
252.   
253.         String key = map.get(view);  
254.         if("0".equals(mShowInputTv.getText().toString())){  
255.             mShowInputTv.setText("0"+key);  
256.             mInputList.set(0,new InputItem("0",InputItem.InputType.INT_TYPE));  
257.         }else{  
258.         mShowInputTv.setText(mShowInputTv.getText() + key);  
259.         }  
260.         addInputList(INPUT_OPERATOR, key);  
261.     }  
262.     /** 
263.      * 回退操作 
264.      */  
265.     private void back() {  
266.         if(mLastInputstatus == ERROR){  
267.             clearInputScreen();  
268.         }  
269.         String str = mShowInputTv.getText().toString();  
270.         if(str.length() != 1){  
271.             mShowInputTv.setText(str.substring(0, str.length()-1));  
272.             backList();  
273.         }else{  
274.             mShowInputTv.setText(getResources().getString(R.string.zero));  
275.             clearScreen(new InputItem("",InputItem.InputType.INT_TYPE));  
276.         }  
277.     }  
278.     /** 
279.      * 回退InputList操作 
280.      */  
281.     private void backList() {  
282.         InputItem item = mInputList.get(mInputList.size() - 1);  
283.         if (item.getType() == InputItem.InputType.INT_TYPE) {  
284.             //获取到最后一个item,并去掉最后一个字符  
285.             String input = item.getInput().substring(0,  
286.                     item.getInput().length() - 1);  
287.             //如果截完了，则移除这个item，并将当前状态改为运算操作符  
288.             if ("".equals(input)) {  
289.                 mInputList.remove(item);  
290.                 mLastInputstatus = INPUT_OPERATOR;  
291.             } else {  
292.                 //否则设置item为截取完的字符串，并将当前状态改为number  
293.                 item.setInput(input);  
294.                 mLastInputstatus = INPUT_NUMBER;  
295.             }  
296.             //如果item是运算操作符 则移除。  
297.         } else if (item.getType() == InputItem.InputType.OPERATOR_TYPE) {  
298.             mInputList.remove(item);  
299.             if (mInputList.get(mInputList.size() - 1).getType() == InputItem.InputType.INT_TYPE) {  
300.                 mLastInputstatus = INPUT_NUMBER;  
301.             } else {  
302.                 mLastInputstatus = INPUT_POINT;  
303.             }  
304.             //如果当前item是小数  
305.         } else {  
306.             String input = item.getInput().substring(0,  
307.                     item.getInput().length() - 1);  
308.             if ("".equals(input)) {  
309.                 mInputList.remove(item);  
310.                 mLastInputstatus = INPUT_OPERATOR;  
311.             } else {  
312.                 if (input.contains(".")) {  
313.                     item.setInput(input);  
314.                     mLastInputstatus = INPUT_POINT;  
315.                 } else {  
316.                     item.setInput(input);  
317.                     mLastInputstatus = INPUT_NUMBER;  
318.                 }  
319.             }  
320.         }  
321.     }  
322.     //清理屏  
323.     private void clearAllScreen() {  
324.           
325.         clearResultScreen();  
326.         clearInputScreen();  
327.           
328.     }  
329.     private void clearResultScreen(){  
330.         mShowResultTv.setText("");  
331.     }  
332.       
333.     private void clearInputScreen() {  
334.         mShowInputTv.setText(getResources().getString(R.string.zero));  
335.         mLastInputstatus = INPUT_NUMBER;  
336.         mInputList.clear();  
337.         mInputList.add(new InputItem("", InputItem.InputType.INT_TYPE));  
338.     }  
339.     //计算完成  
340.     private void clearScreen(InputItem item) {  
341.         if(mLastInputstatus != ERROR){  
342.             mLastInputstatus = END;  
343.         }  
344.         mInputList.clear();  
345.         mInputList.add(item);  
346.     }  
347.       
348.     //实现高级运算  
349.     public int findHighOperator(int index) {  
350.         if (mInputList.size() > 1 && index >= 0 && index < mInputList.size())  
351.             for (int i = index; i < mInputList.size(); i++) {  
352.                     InputItem item = mInputList.get(i);  
353.                 if (getResources().getString(R.string.divide).equals(item.getInput())  
354.                         || getResources().getString(R.string.multply).equals(item.getInput())) {  
355.                     int a,b; double c,d;  
356.                     if(mInputList.get(i - 1).getType() == InputItem.InputType.INT_TYPE){  
357.                         a = Integer.parseInt(mInputList.get(i - 1).getInput());  
358.                         if(mInputList.get(i + 1).getType() == InputItem.InputType.INT_TYPE){  
359.                             b = Integer.parseInt(mInputList.get(i + 1).getInput());  
360.                             if(getResources().getString(R.string.multply).equals(item.getInput())){  
361.                                 mInputList.set(i - 1,new InputItem( String.valueOf(a * b),InputItem.InputType.INT_TYPE));  
362.                             }else{  
363.                                 if(b == 0){  
364.                                     mLastInputstatus = ERROR;  
365.                                     if(a==0){  
366.                                         clearScreen(new InputItem(nan,InputType.ERROR));  
367.                                     }else{  
368.                                         clearScreen(new InputItem(infinite,InputType.ERROR));  
369.                                     }  
370.                                     return -1;  
371.                                 }else if(a % b != 0){  
372.                                     mInputList.set(i - 1,new InputItem(String.valueOf((double)a / b),InputItem.InputType.DOUBLE_TYPE));  
373.                                 }else{  
374.                                     mInputList.set(i - 1,new InputItem(String.valueOf((Integer)a / b),InputItem.InputType.INT_TYPE));  
375.                                 }  
376.                             }  
377.                         }else{  
378.                             d = Double.parseDouble(mInputList.get(i + 1).getInput());  
379.                             if(getResources().getString(R.string.multply).equals(item.getInput())){  
380.                                 mInputList.set(i - 1,new InputItem( String.valueOf(a * d),InputItem.InputType.DOUBLE_TYPE));  
381.                             }else{  
382.                                 if(d == 0){  
383.                                     mLastInputstatus = ERROR;  
384.                                     if(a==0){  
385.                                         clearScreen(new InputItem(nan,InputType.ERROR));  
386.                                     }else{  
387.                                         clearScreen(new InputItem(infinite,InputType.ERROR));  
388.                                     }  
389.                                     return -1;  
390.                                 }  
391.                                 mInputList.set(i - 1,new InputItem(String.valueOf(a / d),InputItem.InputType.DOUBLE_TYPE));   
392.                             }  
393.                         }  
394.                     }else{  
395.                         c = Double.parseDouble(mInputList.get(i-1).getInput());  
396.                         if(mInputList.get(i + 1).getType() == InputItem.InputType.INT_TYPE){  
397.                             b = Integer.parseInt(mInputList.get(i + 1).getInput());  
398.                             if(getResources().getString(R.string.multply).equals(item.getInput())){  
399.                                 mInputList.set(i - 1,new InputItem( String.valueOf(c* b),InputItem.InputType.DOUBLE_TYPE));  
400.                             }else{  
401.                                 if(b== 0){  
402.                                     mLastInputstatus = ERROR;  
403.                                     if(c==0){  
404.                                         clearScreen(new InputItem(nan,InputType.ERROR));  
405.                                     }else{  
406.                                         clearScreen(new InputItem(infinite,InputType.ERROR));  
407.                                     }  
408.                                     return -1;  
409.                                 }  
410.                                 mInputList.set(i - 1,new InputItem(String.valueOf(c / b),InputItem.InputType.DOUBLE_TYPE));   
411.                             }  
412.                         }else{  
413.                             d = Double.parseDouble(mInputList.get(i + 1).getInput());  
414.                             if(getResources().getString(R.string.multply).equals(item.getInput())){  
415.                                 mInputList.set(i - 1,new InputItem( String.valueOf(mul(c,d)),InputItem.InputType.DOUBLE_TYPE));  
416.                             }else{  
417.                                 if(d == 0){  
418.                                     mLastInputstatus = ERROR;  
419.                                     if(c==0){  
420.                                         clearScreen(new InputItem(nan,InputType.ERROR));  
421.                                     }else{  
422.                                         clearScreen(new InputItem(infinite,InputType.ERROR));  
423.                                     }  
424.                                     return -1;  
425.                                 }  
426.                                 mInputList.set(i - 1,new InputItem(String.valueOf(div(c, d)),InputItem.InputType.DOUBLE_TYPE));   
427.                             }  
428.                         }  
429.                     }  
430.                     mInputList.remove(i + 1);  
431.                     mInputList.remove(i);  
432.                     return findHighOperator(i);  
433.                 }  
434.             }  
435.         return -1;  
436.   
437.     }  
438.       
439.     public int findLowOperator(int index) {  
440.         if (mInputList.size()>1 && index >= 0 && index < mInputList.size())  
441.             for (int i = index; i < mInputList.size(); i++) {  
442.                     InputItem item = mInputList.get(i);  
443.                 if (getResources().getString(R.string.sub).equals(item.getInput())  
444.                         || getResources().getString(R.string.add).equals(item.getInput())) {  
445.                     int a,b; double c,d;  
446.                     if(mInputList.get(i - 1).getType() == InputItem.InputType.INT_TYPE){  
447.                         a = Integer.parseInt(mInputList.get(i - 1).getInput());  
448.                         if(mInputList.get(i + 1).getType() == InputItem.InputType.INT_TYPE){  
449.                             b = Integer.parseInt(mInputList.get(i + 1).getInput());  
450.                             if(getResources().getString(R.string.add).equals(item.getInput())){  
451.                             mInputList.set(i - 1,new InputItem( String.valueOf(a + b),InputItem.InputType.INT_TYPE));  
452.                             }else{  
453.                             mInputList.set(i - 1,new InputItem(String.valueOf(a - b),InputItem.InputType.INT_TYPE));      
454.                             }  
455.                         }else{  
456.                             d = Double.parseDouble(mInputList.get(i + 1).getInput());  
457.                             if(getResources().getString(R.string.add).equals(item.getInput())){  
458.                                 mInputList.set(i - 1,new InputItem( String.valueOf(a + d),InputItem.InputType.DOUBLE_TYPE));  
459.                             }else{  
460.                                 mInputList.set(i - 1,new InputItem(String.valueOf(a - d),InputItem.InputType.DOUBLE_TYPE));   
461.                             }  
462.                         }  
463.                     }else{  
464.                         c = Double.parseDouble(mInputList.get(i-1).getInput());  
465.                         if(mInputList.get(i + 1).getType() == InputItem.InputType.INT_TYPE){  
466.                             b = Integer.parseInt(mInputList.get(i + 1).getInput());  
467.                             if(getResources().getString(R.string.add).equals(item.getInput())){  
468.                                 mInputList.set(i - 1,new InputItem( String.valueOf(c + b),InputItem.InputType.DOUBLE_TYPE));  
469.                             }else{  
470.                                 mInputList.set(i - 1,new InputItem(String.valueOf(c - b),InputItem.InputType.DOUBLE_TYPE));   
471.                             }  
472.                         }else{  
473.                             d = Double.parseDouble(mInputList.get(i + 1).getInput());  
474.                             if(getResources().getString(R.string.add).equals(item.getInput())){  
475.                                 mInputList.set(i - 1,new InputItem( String.valueOf(add(c, d)),InputItem.InputType.DOUBLE_TYPE));  
476.                             }else{  
477.                                 mInputList.set(i - 1,new InputItem(String.valueOf(sub(c,d)),InputItem.InputType.DOUBLE_TYPE));    
478.                             }  
479.                         }  
480.                     }  
481.                     mInputList.remove(i + 1);  
482.                     mInputList.remove(i);  
483.                     return findLowOperator(i);  
484.                 }  
485.             }  
486.         return -1;  
487.   
488.     }  
489.     //currentStatus 当前状态  9  "9" "+"  
490.     void addInputList(int currentStatus,String inputChar){  
491.         switch (currentStatus) {  
492.         case INPUT_NUMBER:  
493.             if(mLastInputstatus == INPUT_NUMBER){  
494.                 InputItem item = (InputItem)mInputList.get(mInputList.size()-1);  
495.                 item.setInput(item.getInput()+inputChar);  
496.                 item.setType(InputItem.InputType.INT_TYPE);  
497.                 mLastInputstatus = INPUT_NUMBER;  
498.             }else if(mLastInputstatus == INPUT_OPERATOR){  
499.                 InputItem item = new InputItem(inputChar, InputItem.InputType.INT_TYPE);  
500.                 mInputList.add(item);  
501.                 mLastInputstatus = INPUT_NUMBER;  
502.             }else if(mLastInputstatus == INPUT_POINT){  
503.                 InputItem item = (InputItem)mInputList.get(mInputList.size()-1);  
504.                 item.setInput(item.getInput()+inputChar);  
505.                 item.setType(InputItem.InputType.DOUBLE_TYPE);  
506.                 mLastInputstatus = INPUT_POINT;  
507.             }  
508.             break;  
509.         case INPUT_OPERATOR:  
510.                 InputItem item = new InputItem(inputChar, InputItem.InputType.OPERATOR_TYPE);  
511.                 mInputList.add(item);  
512.                 mLastInputstatus = INPUT_OPERATOR;  
513.             break;  
514.         case INPUT_POINT://point  
515.              if(mLastInputstatus == INPUT_OPERATOR){  
516.                  InputItem item1 =  new InputItem("0"+inputChar,InputItem.InputType.DOUBLE_TYPE);  
517.                  mInputList.add(item1);   
518.                  mLastInputstatus = INPUT_POINT;  
519.             }else{  
520.                 InputItem item1 = (InputItem)mInputList.get(mInputList.size()-1);  
521.                 item1.setInput(item1.getInput()+inputChar);  
522.                 item1.setType(InputItem.InputType.DOUBLE_TYPE);  
523.                 mLastInputstatus = INPUT_POINT;  
524.             }  
525.             break;  
526.         }  
527.     }  
528.       
529.        public static Double div(Double v1,Double v2){  
530.             BigDecimal b1 = new BigDecimal(v1.toString());  
531.             BigDecimal b2 = new BigDecimal(v2.toString());  
532.             return b1.divide(b2,10,BigDecimal.ROUND_HALF_UP).doubleValue();  
533.         }  
534.          
535.        public static Double sub(Double v1,Double v2){  
536.             BigDecimal b1 = new BigDecimal(v1.toString());  
537.             BigDecimal b2 = new BigDecimal(v2.toString());  
538.             return b1.subtract(b2).doubleValue();  
539.         }  
540.          
541.        public static Double add(Double v1,Double v2){  
542.             BigDecimal b1 = new BigDecimal(v1.toString());  
543.             BigDecimal b2 = new BigDecimal(v2.toString());  
544.             return b1.add(b2).doubleValue();  
545.         }  
546.          
547.        public static Double mul(Double v1,Double v2){  
548.             BigDecimal b1 = new BigDecimal(v1.toString());  
549.             BigDecimal b2 = new BigDecimal(v2.toString());  
550.             return b1.multiply(b2).doubleValue();  
551.         }  
552. }