(学习java)利用顺序栈简易计算器的编写

import java.util.Arrays;
import java.util.Scanner;

//简易计算器的编写
//中缀表达式转后缀表达式  ,得出结果用于逆波兰数输出

//例如 输入:(11+2.2)*3.1+(30*45)-((1.1+23)*3.3)/5.2
//转换成后缀表达式: 11 2.2 + 3.1 * 30 45 * + 1.1 23 + 3.3 * 5.2 / -
//输出结果:1375.6257692307693
public class TurnRPN {
public static void main(String[] args) {

char[] s = getChar();
String expression = getExpression(s);
System.out.print("转换成后缀表达式: ");
System.out.println(expression);
//将字符串转换成字符数组
char[] s2 = expression.toCharArray();
ArrStack as = rpn(s2);
System.out.print("输出结果:");
as.listStack();
}

// 将输入的字符串转换成字符数组
public static char[] getChar() {
Scanner sc = new Scanner(System.in);
// 将输入的字符串转换成一个字符数组
System.out.println("请输入中缀表达式(请不要输入空格): ");
char[] s = sc.nextLine().toCharArray();
return s;
}

// 中缀表达式转后缀表达式
public static String getExpression(char[] s) {
ArrStack as = new ArrStack();
// 创建字符串存储后缀表达式
String arr = "";
for (int i = 0; i < s.length; i++) {
// 如果是数字或者.直接放入字符串中
if (isNumber(s[i]) || s[i] == '.') {
arr = arr + s[i];
// 判断数字是否完全输入,如果全部输入完毕,则在后面加上空格
if (i != s.length - 1) {
if (!isNumber(s[i + 1]) && s[i + 1] != '.') {
arr = arr + " ";
}
} else {
// 如果字符的最后一位是数字,则直接加空格(与最后出栈的运算符字符区分)
arr = arr + " ";
}
// 如果是运算符字符,则判断后入栈
} else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') {
// 如果是= -则判断栈顶元素是否为 * / 如果是,先将栈顶元素出栈后再入栈 否则,直接入栈
if (s[i] == '+' || s[i] == '-') {
if (!as.isEmpty()) { // 判断栈是否为空
char r = as.getTop();
while (r == '+' || r == '-' || r == '*' || r == '/') {
r = as.stackPop();
arr = arr + r + " ";
// 如果栈为空,则直接跳出循环
if (!as.isEmpty()) {
r = as.getTop();
} else {
break;
}
}
}
as.stackPush(s[i]);
} else {
as.stackPush(s[i]);
}
// 如果字符是(直接入栈,如果)则栈顶元素依次出栈,直到出栈元素是(为止
} else if (s[i] == '(') {
as.stackPush(s[i]);
} else if (s[i] == ')') {
char r = as.stackPop();
while (r != '(') {
arr = arr + r + " ";
r = as.stackPop();
}
}
}
// 将栈中剩余的元素依次存入字符串中
while (!as.isEmpty()) {
char r = as.stackPop();
arr = arr + r + " ";
}
return arr;
}

// 逆波兰表达式求值
public static ArrStack rpn(char[] s) {
ArrStack as = new ArrStack();
double num = 0;
// 定义空字符串存入字符
String arr = "";
double a = 0;
double b = 0;
double result = 0;
for (int i = 0; i < s.length; i++) {
// 如果是数字或者.则推入栈中
if (isNumber(s[i]) || s[i] == '.') {
arr = arr + s[i];
} else if (s[i] == ' ') {
// 遇到空格,将数据取出转成double类型推入栈中
if (arr == "") {
continue;
} else {
num = Double.valueOf(arr);
as.stackPush(num);
// 字符串置空
arr = "";
}

} else {
// 遇到运算符字符,弹出栈顶前两个数进行运算后再压入栈中
switch (s[i]) {
case '+':
a = as.stackPop();
b = as.stackPop();
result = b + a;
as.stackPush(result);
break;
case '-':
a = as.stackPop();
b = as.stackPop();
result = b - a;
as.stackPush(result);
break;
case '*':
a = as.stackPop();
b = as.stackPop();
result = b * a;
as.stackPush(result);
break;
case '/':
a = as.stackPop();
b = as.stackPop();
if (a == 0) {
System.out.println("除数不能为0!");
break;
}
result = b / a;
as.stackPush(result);
break;

}
}
}
return as;

}

// 判断字符是否为数字
public static boolean isNumber(char c) {
if (c >= 48 && c <= 57) {
return true;
}
return false;
}

// 创建顺序栈
public static class ArrStack {
// 定义数组保存元素
private Object[] elementData;
// 定义栈的当前长度
private int size;
// 定义栈的当前容量
private int capacity;
// 定义栈顶
public int top;

// 初始化,默认建立一个容量为50的数组
public ArrStack() {
elementData = new Object[50];
capacity = 50;
}

// 初始化,自定义容量数组
public ArrStack(int n) {
elementData = new Object
;
capacity = n;
}

// 入栈
public <T> void stackPush(T data) {
// 如果容量满了,则新建一个数组扩充容量
if (size >= capacity) {
int newLength = (capacity * 3 / 2) + 1;
elementData = Arrays.copyOf(elementData, newLength);
capacity = newLength;
}
elementData[top] = data;
top++;
size++;
}

// 出栈
public <T> T stackPop() {
if (size == 0) {
System.out.println("当前为空栈");
return null;
} else {
T data = (T) this.elementData[top - 1];
top--;
size--;
return data;
}

}

// 遍历栈
public void listStack() {
if (size == 0) {
System.out.println("空栈");
} else if (size == 1) {
System.out.println(elementData[top - 1]);
// System.out.println("栈的长度" + size);
} else {
for (int i = 0; i < size; i++) {
System.out.print(elementData[i] + " ");
}
System.out.println("栈的长度" + size);
}
}

// 返回当前容量
public void capacity() {
System.out.println("当前最大容量" + capacity);

}

// 返回当前栈顶的值
public <T> T getTop() {
T data = (T) elementData[top - 1];
return data;
}

// 判空
public boolean isEmpty() {
return size == 0;
}
}
}