一个简单的计算器功能，我是按照老师的课程设计指导书分步骤来的，所以写的垃圾代码比较多，形成了一座“大屎山”，如果正常写的话，完全可以用最后一步将输入数字以及操作符放在栈中进行操作，当select=3时的代码会有一些帮助，输入格式都是带空格的，这里面也包含了一些其他功能：
1.存储最近计算结果
2.浏览所有计算历史
3.根据id查找结果
4.清空历史记录
5.与最近计算结果进行二次运算（支持（opera n）形式）
6.进行带括号运算（但只支持（n opera n) opera (n opera n)形式）
7.包含很多对于输入格式不正确的异常捕捉
这是我写的第一个略微长一点的java程序，垃圾代码比有用代码多哈哈哈
package shiyan.Project;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;
class calculator { //计算器类
String expre; //表达式
int type=0; //表达式是double型运算还是int型运算，type为0，int；为1，double
int div0=0; //evaluate中div0>0，则第二个数字为0
int div1=0; //evalua1中判断除数是否为0
double recent=0; //最近存储
public static ArrayList list=new ArrayList<>(); //集合声明,存储列表
float result=0;
double firstDouble;
double secondDouble;
//构造函数初始化
public calculator(){} //创建存储列表
public calculator(String expre){
this.expre=expre;
}
//判断表达式是否合法
public float evaluate(String expression) {
//以空格为分界符分割
String[] str = expression.split(" ");
//判断str数组长度，不等于3，则error
if (str.length != 3 ) {
System.out.println("Invaild input.");
return Float.MIN_VALUE;
}
//判断是浮点型还是整形
int flag = 0; //标志位，判断是否有小数点，flag=0，则为int
char[] num1 = str[0].toCharArray(); //第一数字字符串，检查是否有小数点
for (int i = 0; i < num1.length; i++) {
if (num1[i] == '.') {
flag++;
}
}
char[] num2 = str[2].toCharArray(); //第二数字字符串，检查是否有小数点
for (int i = 0; i < num2.length; i++) {
if (num2[i] == '.') {
flag++;
}
}
//判断flag
if (flag == 0) {
type = 0;
} else {
type = 1;
}
//转换为数字
//将字符串转换成double形式，若错误输入如：9@ + 9等等，会报错，所以采用异常处理
try{
firstDouble = Double.parseDouble(str[0]);
secondDouble = Double.parseDouble(str[2]);
}
catch(Exception ex){ //若转换出现异常，则报错
System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
if (secondDouble == 0) {
div0++; //判断第二个数字是否为0
}
//判断运算符是否有效 and 计算结果，暂时都是double型
switch (str[1]) {
case "+": {
result = (float) (firstDouble + secondDouble);
break;
}
case "-": {
result = (float) (firstDouble - secondDouble);
break;
}
case "*": {
result = (float) (firstDouble * secondDouble);
break;
}
case "/": {
if (div0 != 0) { //判断第二个数字是否为0
System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
} else {
result = (float) (firstDouble / secondDouble);
break;
}
}
default:{System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
}
return 1;
}
//返回运行结果
public float getCurrentValue(){
if (type==0){ //int型输出
int FianlResult=(int)(result);
System.out.println("运算结果为"+FianlResult);
return FianlResult;
}
else{ //double型输出
System.out.println("运算结果为"+result);
return (float)(result);
}
}
//设置最近存储结果
public void setMemoryValue(float memval){
recent=memval;
list.add(recent);
//System.out.println("历史记录为"+list);
}
//清空列表
public void clearMemory(){
list.clear();
}
//获取全部存储结果
public float getMemoryValue(){
for (int i=0;i<list.size();i++){
System.out.print(list.get(i));
System.out.print(" ");
}
return 0;
}
//获得某个存储结果
public float getHistoryValue(int index){
try{ //可能出现数组越界，有异常捕捉
System.out.println(list.get(index));
}catch(Exception ex){
System.out.println("数组越界，输入错误");
}
return 0;
}
//再次计算
public float evaluate1(String expression1,float m){
String[] str1=expression1.split(" ");
if (str1.length != 2) {
System.out.println(expression1);
System.out.println("Invaild input.");
return Float.MIN_VALUE;
}
//判断是浮点型还是整形
int flag = 0; //标志位，判断是否有小数点，flag=0，则为int
char[] num1 = str1[1].toCharArray();
for (int i = 0; i < num1.length; i++) {
if (num1[i] == '.') {
flag++;
}
}
//判断flag
if (flag == 0) {
type = 0;
} else {
type = 1;
}
try {
firstDouble = Double.parseDouble(str1[1]);
}
catch(Exception ex){ //若转换出现异常，则报错
System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
if (firstDouble == 0) {
div1++; //判断第二个数字是否为0
}
//判断运算符是否有效 and 计算结果，暂时都是double型
switch (str1[0]) {
case "+": {
result = (float) (firstDouble + m);
break;
}
case "-": {
result = (float) (m-firstDouble );
break;
}
case "*": {
result = (float) (firstDouble * m);
break;
}
case "/": {
if (div1 != 0) { //判断第二个数字是否为0
System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
} else {
result = (float) (m/firstDouble);
break;
}
}
default:{System.out.println("Invaild input.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
}
return result;
}
//带括号计算
public float evaluate2(String expression){
//以空格为分界符分割
String[] str = expression.split(" ");
//判断str数组长度，不等于7，则error
//System.out.println(str.length);
if (str.length != 7 ) {
System.out.println("Invaild input1.");
return Float.MIN_VALUE;
}
//处理括号
str[0]= str[0].substring(1);
str[2]=str[2].substring(0,str[2].length()-1);
String opera=str[3];
str[4]= str[4].substring(1);
str[6]=str[6].substring(0,str[6].length()-1);
//转换为数字
//将字符串转换成double形式，若错误输入如：9@ + 9等等，会报错，所以采用异常处理
try{
firstDouble = Double.parseDouble(str[0]);
secondDouble = Double.parseDouble(str[2]);
}
catch(Exception ex){ //若转换出现异常，则报错
System.out.println("Invaild input2.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
//System.out.println(str[1]);
//判断运算符是否有效 and 计算结果，暂时都是double型
switch (str[1]) {
case "+": {
result = (float) (firstDouble + secondDouble);
break;
}
case "-": {
result = (float) (firstDouble - secondDouble);
break;
}
case "*": {
result = (float) (firstDouble * secondDouble);
break;
}
case "/": {
if (div0 != 0) { //判断第二个数字是否为0
System.out.println("Invaild input3.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
} else {
result = (float) (firstDouble / secondDouble);
break;
}
}
default:{System.out.println("Invaild input5.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
}
float r1=result;
//处理第二个表达式
try{
firstDouble = Double.parseDouble(str[4]);
secondDouble = Double.parseDouble(str[6]);
}
catch(Exception ex){ //若转换出现异常，则报错
System.out.println("Invaild input2.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
//判断运算符是否有效 and 计算结果，暂时都是double型
switch (str[5]) {
case "+": {
result = (float) (firstDouble + secondDouble);
break;
}
case "-": {
result = (float) (firstDouble - secondDouble);
break;
}
case "*": {
result = (float) (firstDouble * secondDouble);
break;
}
case "/": {
if (div0 != 0) { //判断第二个数字是否为0
System.out.println("Invaild input3.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
} else {
result = (float) (firstDouble / secondDouble);
break;
}
}
default:{System.out.println("Invaild input4.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
}
float r2=result;
switch (opera) {
case "+": {
result = r1 + r2;
break;
}
case "-": {
result = r1 - r2;
break;
}
case "*": {
result = r1 * r2;
break;
}
case "/": {
if (div0 != 0) { //判断第二个数字是否为0
System.out.println("Invaild input3.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
} else {
result = r1 / r2;
break;
}
}
default:{System.out.println("Invaild input5.");
return Float.MIN_VALUE;//若不合法，则输出MIN_VALUE
}
}
System.out.println("运算结果为："+result);
return result;
}
}
public class Homework {
//main 函数
public static void main(String[] args) {
Stack s1=new Stack<>();//运算栈
Stack s2=new Stack<>();//中间结果栈
Stack s3=new Stack<>();
calculator c=new calculator();//存储对象，用来存储计算记录
float m=0; //存储最近一次计算结果
while (true){
System.out.println();
System.out.println("输入表达式:");
Scanner input=new Scanner(System.in);
String expression= input.nextLine(); //输入带空格表达式
System.out.println("选择模式：（1-不带括号的简单运算，2-带括号的多值运算，3-不带括号的多值运算）");
int select=input.nextInt();
if (select==2){
calculator d=new calculator(expression);
m=d.evaluate2(expression);
}
else if (select==1){
calculator d=new calculator(expression);
double Isok=d.evaluate(expression); //判断是否有效
if (Isok==1) { //有效继续
m=d.getCurrentValue(); //返回计算结果
}
}
else if (select==3){
String[] opera=expression.split(" ");
//System.out.println(opera.length);
for (int i=0;i< opera.length;i++){
if (i%2==0){
try{
float temp=Float.parseFloat(opera[i]);
s2.push(temp);
}catch(Exception ex){
System.out.println("Input Illegelly");
}
}
else{
if (s1.isEmpty()){
s1.push(opera[i]);
}
else if ((opera[i].equals("*") || opera[i].equals("/")&&(s1.peek().equals("+")||s1.peek().equals("-")))){
s1.push(opera[i]);
}
else{
s2.push(s1.pop());
i--;
}
}
}
while (!s1.isEmpty()){
s2.push(s1.pop());
}
while(!s2.isEmpty()){
s1.push(s2.pop());
}
while (!s1.isEmpty()){
String op="";
float result=0;
try{
op=s1.pop().toString();
float temp=Float.parseFloat(op);
s3.push(temp);
}catch(Exception exception){
float op1= Float.parseFloat(s3.pop().toString());
float op2= Float.parseFloat(s3.pop().toString());
switch (op){
case "+":{result=op2+op1;break;}
case "-":{result=op2-op1;break;}
case "*":{result=op1*op2;break;}
case "/":{result=op2/op1;break;}
}
s3.push(result);
}
}
m=(float)(s3.pop());
System.out.println(m);
}
System.out.println("解下来的操作（m-存储、c-清空、mr-历史结果、h-查找、over-结束任务）：");
Scanner next=new Scanner(System.in);
String key=next.next(); //输入接下来的操作
switch (key){
case "m":{c.setMemoryValue(m); //存储并且选择实现第二次运算
System.out.println("接下来的操作（i-输入表达式、n-取消）：");
String n= input.next();
switch (n){
case "n":{continue;} //不进行运算
case "i":{ //进行运算并输入表达式
System.out.println("上一次运算结果为"+m);
System.out.println("输入表达式（operator[space]operand）:");
Scanner input1=new Scanner(System.in);
String expression1=input1.nextLine();
float k =c.evaluate1(expression1,m); //返回结果
if (k!=Float.MIN_VALUE){
System.out.println("运算结果为"+k);
}
break;}
}
break;}
case "c":{c.clearMemory();break;} //清空
case "mr":{c.getMemoryValue();break;}
case "h":{
System.out.println("选择你想要查找的id：");
int id=next.nextInt(); //输入想要查找的id
c.getHistoryValue(id);break;}
case "over":{return;}
default:{System.out.println("Invaild input.");}
}
}}}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
