189 8069 5689
用java写的计算器的程序，主要是通过控制台输入，主要方法是使用scanner类来接收用户从键盘输入的一个算式，通过分解算式，存入两个字符串，判断中间的的符号，进行相应计算，如下代码：
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、雅安服务器托管、营销软件、网站建设、桑日网站维护、网站推广。
System.out.println("-----------------------------------");
System.out.println("请输入一个算术表达式，如：45*23");
Scanner in = new Scanner(System.in);//接收用户从键盘输入的字符
String str = in.nextLine();
StringBuffer buffer = new StringBuffer();//保存左侧的数字
StringBuffer buffer1 = new StringBuffer();//保存右侧的数字
char t = ' ';//保存运算符
for (int i = 0; i str.length(); i++) {
if (str.charAt(i) == '+' || str.charAt(i) == '-'
|| str.charAt(i) == '*' || str.charAt(i) == '/') {
t = str.charAt(i);//识别是什么运算符
for (int j = i + 1; j str.length(); j++) {
buffer1.append(str.charAt(j));
}
break;
} else {
buffer.append(str.charAt(i));
}
}
String c = buffer.toString();
String d = buffer1.toString();
double a = Double.parseDouble(c);
double b = Double.parseDouble(d);
double sum = 0;
if (t == '+') {
sum = a + b;
}
if (t == '-') {
sum = a - b;
}
if (t == '*') {
sum = a * b;
}
if (t == '/') {
sum = a / b;
}
System.out.println("程序运算...");
System.out.println(c+t+d+"="+sum);
System.out.print("-----------------------------------");
运行结果如下：
代码网上很多，只说说算法吧
12+8/4-5+(3-4)
把这样的表达式拆成：(操作数)(操作符) 、
12+
8/
4-
5+(
3-
4)
(术语叫做逆波兰式)
默认的计算顺序是从左往右，记为left。另设从右往左，记为right
设计Element类，具有 操作数 operant, 操作符operator, 操作顺序 order三个属性
用两个先进后出的栈结构StackElement a,b;
一开始所有的Element都在a中，逐个弹出计算合并值，
当遇到乘、除、括号时计算顺序改变成right，把当前结果放到b中暂存。
直到再次遇到加、减、)右括号时，意味计算顺序复位成left，先把b中的暂存结果全部合并后，再继续算a中的剩余数据
最后合并成一个结果值。
表达式求值 逆波兰表达式算法 如下：
import java.util.ArrayList;
import java.util.List;
public class MyStack {
private ListString l;
private int size;
public String top;
public MyStack() {
l = new ArrayListString();
size = 0;
top = null;
}
public int size() {
return size;
}
public void push(String s) {
l.add(s);
top = s;
size++;
}
public String pop() {
String s = l.get(size - 1);
l.remove(size - 1);
size--;
top = size == 0 ? null : l.get(size - 1);
return s;
}
}
import java.util.ArrayList;
import java.util.List;
public class Nbl {
private static MyStack ms1 = new MyStack();//生成逆波兰表达式的栈
private static MyStack ms2 = new MyStack();//运算栈
/**
* 将字符串转换为中序表达式
*/
public static ListString zb(String s) {
ListString ls = new ArrayListString();//存储中序表达式
int i = 0;
String str;
char c;
do {
if ((c = s.charAt(i)) 48 || (c = s.charAt(i)) 57) {
ls.add("" + c);
i++;
} else {
str = "";
while (i s.length() (c = s.charAt(i)) = 48
(c = s.charAt(i)) = 57) {
str += c;
i++;
}
ls.add(str);
}
} while (i s.length());
return ls;
}
/**
* 将中序表达式转换为逆波兰表达式
*/
public static ListString parse(ListString ls) {
ListString lss = new ArrayListString();
for (String ss : ls) {
if (ss.matches("\d+")) {
lss.add(ss);
} else if (ss.equals("(")) {
ms1.push(ss);
} else if (ss.equals(")")) {
while (!ms1.top.equals("(")) {
lss.add(ms1.pop());
}
ms1.pop();
} else {
while (ms1.size() != 0 getValue(ms1.top) = getValue(ss)) {
lss.add(ms1.pop());
}
ms1.push(ss);
}
}
while (ms1.size() != 0) {
lss.add(ms1.pop());
}
return lss;
}
/**
* 对逆波兰表达式进行求值
*/
public static int jisuan(ListString ls) {
for (String s : ls) {
if (s.matches("\d+")) {
ms2.push(s);
} else {
int b = Integer.parseInt(ms2.pop());
int a = Integer.parseInt(ms2.pop());
if (s.equals("+")) {
a = a + b;
} else if (s.equals("-")) {
a = a - b;
} else if (s.equals("*")) {
a = a * b;
} else if (s.equals("\")) {
a = a / b;
}
ms2.push("" + a);
}
}
return Integer.parseInt(ms2.pop());
}
/**
* 获取运算符优先级
* +,-为1 *,/为2 ()为0
*/
public static int getValue(String s) {
if (s.equals("+")) {
return 1;
} else if (s.equals("-")) {
return 1;
} else if (s.equals("*")) {
return 2;
} else if (s.equals("\")) {
return 2;
}
return 0;
}
public static void main(String[] args) {
System.out.println(jisuan(parse(zb("0-8+((1+2)*4)-3+(2*7-2+2)"))));
}
}
while(Character.isDigit(chars[i])||chars[i]=='.') {
s.append(chars[i]);
}
这一段是死循环。。stack一直追加参数，所以溢出了
import java.util.Stack;
/**
* @author wengsh
* @date 2010-6-3 用 输入 (6+5)*(5+5) 测试一下
*/
public class MyDemo {
public static void main(String[] a) {
StackCharacter stack = new StackCharacter();
StringBuffer sb = new StringBuffer();
if (a.length 1) {
System.out.println("参数长度不够");
} else {
String s = a[0].trim();
char[] c = s.toCharArray();
try {
for (int i = 0; i c.length; i++) {
int priority = getPriority(c[i]);
if (priority == -1) { // 如果是数字
sb.append(c[i]); // 输出数字或都字母
} else {
if (stack.isEmpty()) {// 当栈为空时
stack.push(c[i]); // 把字符压入栈
} else {// 当栈为不空时
if (priority == -2) { // 如果是 ')'
while (!stack.isEmpty()
getPriority(stack.peek()) != 8) {
sb.append(stack.pop());// 把'('之上的字符弹出栈并输出
}
stack.pop(); // 栈弹出'('
} else {
// 当要压入栈的字符的优先级小于 等于栈顶字符的优先级且栈顶字符不为'('时
while (!stack.isEmpty()
priority = getPriority(stack.peek())
getPriority(stack.peek()) != 8) {
sb.append(stack.pop()); // 弹出栈顶字符并输出
}
stack.push(c[i]);// 将此时的字符压入栈顶
}
}
}
}
// 读到输入末尾
while (!stack.isEmpty()) {
sb.append(stack.pop()); // 弹出栈中所有元素并输出
}
System.out.println(sb); // 结果 65+55+*
System.out.println(calstack(sb.toString()));//结果 110.0
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 获得字符串优先级如果字符不在给定的范围内,则抛出异常,数字和字母的优先级最低
*
* @param c
* @return
* @throws Exception
*/
public static int getPriority(char c) throws Exception {
int priority = -1;
if (Character.isDigit(c)) {
priority = -1;
} else if (Character.isLetter(c)) {
priority = 0;
} else {
if (c == '(') {
priority = 8;
} else if (c == '*' || c == '/') {
priority = 5;
} else if (c == '+' || c == '-') {
priority = 4;
} else if (c == ')') {
priority = -2;
} else {
throw new Exception("无法解析的前序表达式: " + c);
}
}
return priority;
}
/**
* 计算栈结果
* 6+5*8
* @param s
* @return
*/
public static float calstack(String s) {
StackFloat stack = new StackFloat();
char[] c = s.toCharArray();
try {
for (int i = 0; i c.length; i++) {
int priority = getPriority(c[i]);
if (priority == -1) {
stack.push(new Float(Character.digit(c[i], 10)));
} else {
stack.push(cal(stack.pop(), stack.pop(), c[i]));
}
}
} catch (Exception e) {
e.printStackTrace();
}
return stack.pop();
}
/**
* a b 运算
* @param a
* @param b
* @param opertor
* @return
*/
public static float cal(float a, float b, char opertor) {
float r = 0;
switch (opertor) {
case '+':
r = a + b;
break;
case '-':
r = a - b;
break;
case '*':
r = a * b;
break;
case '/':
r = a / b;
break;
}
return r;
}
}
下面的代码是用来计算表达式的，看看是不是你要的
public class OPNode {
char op;// 运算符号
int level;// 优先级
//设置优先级
public OPNode(String op) {
this.op = op.charAt(0);
if (op.equals("+") || op.equals("-")) {
this.level = 1;
} else if (op.equals("*") || op.equals("/")) {
this.level = 2;
} else if (op.equals("(")) {
this.level = -3;
} else {
this.level = -1;
}
}
}
//主类
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class OPText {
public static void main(String[] args) {
String expression = "2+2+(8-2)/3";// 要计算的表达式
List list = new LinkedList();
//正则式
Pattern entryOfExpression = Pattern
.compile("[0-9]+(\\.[0-9]+)?|\\(|\\)|\\+|-|\\*|/");
Deque stack = new LinkedList();//栈
Matcher m = entryOfExpression.matcher(expression);
while (m.find()) {
//提取语素
String nodeString = expression.substring(m.start(), m.end());
if (nodeString.matches("[0-9].*")) {
list.add(Double.valueOf(nodeString));//如果是数字直接送入列表
} else {
OPNode opn = new OPNode(nodeString);//如果是运算符
int peekLevel = (stack.peek() == null) ? 0 : ((OPNode) stack
.peek()).level;
if (opn.level =peekLevel) {
stack.push(opn);//新的运算符比旧的优先级别高则入栈
} else {
if (opn.level == -1) {
OPNode temp = (OPNode) stack.pop();
while (temp.level != -3) {//如果为"("则一直出栈一直到")"
list.add(temp);
System.out.println(nodeString);
temp = (OPNode) stack.pop();
}
} else if (opn.level == -3) {
stack.push(opn);
} else {//如果新运算符比栈顶运算符底则一直出栈
OPNode temp = (OPNode) stack.pop();
while (temp.level opn.level) {
list.add(temp);
if (stack.isEmpty()) {
break;
}
temp = (OPNode) stack.pop();
}
stack.push(opn);
}
}
}
}
OPNode temp = null;
while (!stack.isEmpty()) {
temp = (OPNode) stack.pop();
list.add(temp);
}//后续表达式计算
stack.clear();
for (Object o : list) {
if (o instanceof Double) {
stack.push(o);//为数字入栈
} else {
double op2 = ((Double) stack.pop()).doubleValue();
double op1 = ((Double) stack.pop()).doubleValue();
switch (((OPNode) o).op) {
case '+':
stack.push(op1 + op2);
break;
case '-':
stack.push(op1 - op2);
break;
case '*':
stack.push(op1 * op2);
break;
case '/':
stack.push(op1 / op2);
break;
}
}
}
System.out.println("结果为:" + stack.pop());
}
}
呃，太晚了，没心思去改了
明天再说