java高难度题（1000行左右的代码） ，一般水平的别看

Question

就是写一个类(可以有多个方法，数字自己随便定)，里面包含+，－，x ，％，（），/的数学运算，要求返回一个字符串（并且要进行四舍五入） 也就是用java代码实现 ‘（1+2×3％（5-2））+（6/2）’（要考虑到优先级以及括号是否匹配的问题）。

Answer 1

不知道你学过C语言没有，这是我用C语言写的。
基本思想都是一样的……
很长 ，你慢慢看吧……呵呵……
/*calculator.h头文件*/
#include<stdio.h>
#include<string.h>
#define MAX_LEN 200
unsigned int an1[MAX_LEN+10];
unsigned int an2[MAX_LEN+10];
unsigned int aresult[MAX_LEN*2+10];
char szline1[MAX_LEN+10];
char szline2[MAX_LEN+10];
void add()
{

printf("请输入两个要运算的大整数:\n");
scanf("%s",szline1);
scanf("%s",szline2);
int i,j;
memset(an1,0,sizeof(an1));//库函数memeset将地址an1开始的sizeof(an1)字节内容置成0
memset(an2,0,sizeof(an2)); //下面将szline1中存储的字符串形式的整数转换到an1中去
//an1[0]对应于个位
int nlen1=strlen(szline1);
j=0;
for(i=nlen1-1;i>=0;i--)
an1[j++]=szline1[i]-'0'; int nlen2=strlen(szline2);
j=0;
for(i=nlen2-1;i>=0;i--)
an2[j++]=szline2[i]-'0'; for(i=0;i<MAX_LEN;i++)
{
an1[i]+=an2[i];
if(an1[i]>=10)//看是否要进位
{
an1[i]-=10;
an1[i+1]++;//进位
}
}
printf("计算的结果为：\n");
bool bstartoutput=false;
for(i=MAX_LEN;i>=0;i--)
if(bstartoutput)
printf("%d",an1[i]);
else if(an1[i]){
printf("%d",an1[i]);
bstartoutput=true;
}
}
void multiply()
{
printf("请输入两个要运算的大整数:\n");
scanf("%s",szline1);
scanf("%s",szline2);
int i,j;
memset(an1,0,sizeof(an1));//库函数memeset将地址an1开始的sizeof(an1)字节内容置成0
memset(an2,0,sizeof(an2));
memset(aresult,0,sizeof(aresult));
//下面将szline1中存储的字符串形式的整数转换到an1中去
//an1[0]对应于个位
int nlen1=strlen(szline1);
j=0;
for(i=nlen1-1;i>=0;i--)
an1[j++]=szline1[i]-'0'; int nlen2=strlen(szline2);
j=0;
for(i=nlen2-1;i>=0;i--)
an2[j++]=szline2[i]-'0';
//*******************************************************
//以下为进行计算
for(i=0;i<nlen2;i++){//每一都用an1的一位，去和an2各位相乘
//从an1的个位开始
for(j=0;j<nlen1;j++)//用选定的an1的那一位，去乘an2的各位
aresult[i+j]+=an2[i]*an1[j];//两数第i,j位相乘，累加到结果的第i+j位
}
//下面的循环统一处理进位问题
for(i=0;i<MAX_LEN*2;i++)
{
if(aresult[i]>=10){
aresult[i+1]+=aresult[i]/10;
aresult[i]%=10;
}

}
printf("计算的结果为：\n");
bool bstartoutput=false;
for(i=MAX_LEN*2;i>=0;i--){
if(bstartoutput)
printf("%d",aresult[i]);
else if(aresult[i]){
printf("%d",aresult[i]);
bstartoutput=true;
}
}
}
/*LinkStack_Char.h头文件*/
//这个栈是用来存储符号字符的
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define NULL 0
typedef char ElemType;
typedef int Status;
typedef struct node1{
ElemType data;
struct node1 *next;
}StackCharNode,*LinkCharStack;
void CInitCharStack(LinkCharStack &head){
head=(LinkCharStack)malloc(sizeof(StackCharNode));
head->next=NULL;
}
int CIsEmpty(LinkCharStack head){
return (head->next==NULL)?TRUE:FALSE;
}
int CPush(LinkCharStack &head,ElemType element){
LinkCharStack temp=(LinkCharStack)malloc(sizeof(StackCharNode));
if(!temp)return ERROR;
temp->data=element;
temp->next=head->next;
head->next=temp;
return TRUE;
}
int CPop(LinkCharStack &head,ElemType &element){
if(CIsEmpty(head))return FALSE;
StackCharNode *temp=head->next;
element=temp->data;
head->next=temp->next;
free(temp);
return TRUE;
}
int CGetTop(LinkCharStack head,ElemType &element){
if(head->next!=NULL)
{
element=head->next->data;
return TRUE;
}
element='#';
return FALSE;
}
Status CDestroyStack(LinkCharStack &head){
LinkCharStack q;
while(head)
{
q=head->next;
free(head);
head=q;
}
return TRUE;
}
/*LinkStack.h头文件*/
//这个栈是用来存储数字符的
#include<stdlib.h>
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0typedef double ElementType;
typedef int Status;
typedef struct node{
    ElementType data;
    struct node *next;
}StackNode, *LinkStack;void InitStack(LinkStack &head){
    head=(LinkStack)malloc(sizeof(StackNode)); 
head->next=NULL;
}
Status IsEmpty(LinkStack head){
if(head->next==NULL)return TRUE;
else return ERROR;
}Status Push(LinkStack &head,ElementType element){//入栈
LinkStack p;
p=(LinkStack)malloc(sizeof(StackNode));
if(p== NULL) return FALSE;
p->data=element;
p->next=head->next;
head->next=p;
return OK;
}
Status Pop(LinkStack &head,ElementType &element){//出栈
if(IsEmpty(head))return FALSE;
LinkStack temp=head->next;
    element=temp->data;
head->next=temp->next;
free(temp);
return OK;
}
int GetTop(LinkStack head, ElementType &element){
if(head->next==NULL)
return ERROR;
        element =head->next->data;
return OK;
}
Status DestroyStack(LinkStack &head)
{
 LinkStack q;
 while(head)
 {
 q=head->next;
 free(head);
 head=q;
 }
 return TRUE;
}

Answer 2

//Calculator.cpp# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# include "LinkStack.h"
# include "LinkCharStack.h"
# include "calculator.h"
# define STACK_INIT_SIZE 30
# define STACKINCREAMENT 10
# define NUMBER 30
//判断ch是否为运算符
int Comop(char ch)
{
switch(ch)
{
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
case '#':return 1;
default:return 0;
}}//Comop
//比较两个运算符的优先级
char Precede(char ch,char c)//ch是栈顶字符,c 是表达式字符
{
switch(ch)
{
case '+':
case '-':
if(c=='+'||c=='-'||c==')'||c=='#')return '>';
if(c=='*'||c=='/'||c=='(')return '<';
case '*':
case '/':
if(c=='+'||c=='-'||c=='*'||c=='/'||c==')'||c=='#')return '>';
if(c=='(')return '<';
case '(':
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='(')return '<';
if(c==')')return '=';
        if(c=='#')return ' ';
case ')':
if(c=='+'||c=='-'||c=='*'||c=='/'||c==')')return '>';
if(c=='(')return ' ';
if(c=='#')return '>';
case '#':
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='(')return '<';
if(c==')')return ' ';
if(c=='#')return '=';
default:
return '$';
}
}//precede
//运算函数
ElementType Operate(ElementType a,char ch,ElementType b)
{
switch(ch)
{
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':
if(b==0)
{
return -32767;
}
return a/b;
default:
return -32767;
}}//Operate
//错误提示函数
int error(char *str)   //在用的过程中可以不断扩充错误的类型
{
 int i=0,err=0;
 while(str[i]!='#') //主要通过判断所有输入的字符数组str[30]
 {
 if(err==1  //err是为有些字符并不满足其它函数而设的一个错误点                                                  
     ||(
     (str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/'||str[i]=='.')  
     &&        //其它函数只要一声明err=1也就说明输入有误
     (str[i+1]==')')
       )
     ||(
        (str[i]=='+'||str[i]=='*'||str[i]=='/'||str[i]=='.')
     &&
     (str[i-1]=='(')
       )
     ||(str[i]==')' && str[i+1]=='.')
     ||(str[i]=='.' && str[i+1]=='(')
     ||(str[i]==')' && str[i+1]=='(')
     ||(str[i]=='(' && str[i+1]==')')
 ||(str[i]==')' && str[i+1]>='0'&&str[i+1]<='9')
 ||(str[i]>='0'&&str[i]<='9'&& str[i+1]=='(')
     ||(str[0]=='+'||str[0]=='*'||str[0]=='/'||str[0]==')')                                
     ||(
     (str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/'||str[i]=='.')  
     &&
     (str[i+1]=='+'||str[i+1]=='-'||str[i+1]=='*'||str[i+1]=='/'||str[i+1]=='.'))
   
     ||(int(str[i])>57)
     ||(str[i]=='/' && str[i+1]=='0')
     ||(int(str[i])>31 && int(str[i])<38)
     )
    return 1;
    else if(str[i]=='#')return 0;
   i++;
 }//while
  return 0;
 
}//错误提示函数
//表达式计算
ElementType EvaluateExpression(char *exp){
char c,ch;      //c代表输入表达式中的字符，ch代表栈顶运算符
char *p,*q,*temp;//temp指向运算符后面的一个字符
double i=0,a=0,b=0;
p=q=exp;
LinkCharStack OPTR;//运算符栈
LinkStack OPND;//操作数栈
CInitCharStack(OPTR);CPush(OPTR,'#');
InitStack(OPND);
c=*p;temp=p;p++;
if(c=='-')
{
c=*p;temp=p;p++;
}
while(c!='#'||!CIsEmpty(OPTR))   //栈不为空或表达式没有结束
{//*********************进入最外层循环*********************
if(!Comop(c))//不是运算符则解析数字字符串然后进操作数栈
{
double m=0,n=0;
while(c!='.'&&c>='0'&&c<='9')
{//解析整数部分
m=m*10+(c-48);
c=*p;
p++;
}
if(c=='.')
{//解析小数部分
c=*p;
while(c>='0'&&c<='9')
{p++;c=*p;}
q=p;
p--;
while(*p!='.')
{
n=n/10+(*p-48)/10.0;
p--;
}
p=q;
p++;
}
if(*(temp-2)=='('&&*(temp-1)=='-'||temp-1==exp)
Push(OPND,-(m+n));
else 
Push(OPND,m+n);
}//*****数字进栈结束******
else//是运算符时则进栈OPTR
{
if(c=='-'&&*(p-2)=='(')
{
c=*p;
temp=p;
p++;
}
else//else1
{
CGetTop(OPTR,ch);
switch(Precede(ch,c))
{
case '<'://栈顶运算符优先权低
CPush(OPTR,c);c=*p;temp=p;p++;break;
case '>'://栈顶运算符优先权高
CPop(OPTR,ch);
Pop(OPND,b);Pop(OPND,a);
Push(OPND,Operate(a,ch,b));break;
case '='://脱括号并接收下一个字符
CPop(OPTR,ch);c=*p;temp=p;p++;break;
default:
c=*p;temp=p;p++;
}//switch
}//else1
}//else2
}//*********************退出最外层循环*********************
GetTop(OPND,i);
DestroyStack(OPND);
CDestroyStack(OPTR);
return i;
}//******************EvaluateExpression函数结束********************
//菜单函数
void MenuPrint()
{
 printf("\t\t┌───────┐\n");
 printf("\t\t│ 多功能计算器 │\n");
 printf("\t\t├(a)表达式求解 │\n");
 printf("\t\t├(b)大整数运算 │\n");
 printf("\t\t├(c)清屏       │\n");
 printf("\t\t├(d)退出       │\n");
 printf("\t\t└───────┘\n");
 printf("\t\t请输入你要进行的操作:");
} //菜单函数
void submenu()
{
printf("\t\t┌──────────┐\n");
printf("\t\t│（1）两个大整数相加 │\n");
printf("\t\t│（2）两个大整数相乘 │\n");
printf("\t\t│（3）返回上级菜单   │\n");
printf("\t\t│（4）退出本程序     │\n");
printf("\t\t└──────────┘\n");
printf("\t\t请选择：");
}
//清屏函数
void Clear()
{
char a;
    printf("请按回车键 继续……\n");
    a=getchar();
a=getchar();
system("cls");
}//清屏函数
void main()
{
double result=0;
char exp[NUMBER],c;
while(1)
{
Clear();
MenuPrint();
scanf("%c",&c);
switch(c)
{
case 'a':
printf("输入要计算的表达式，以##结束\n");
scanf("%s",exp);
if(!error(exp))
{
result=EvaluateExpression(exp);
printf("计算结果为：%lf\n",result);
}
else 
if(error(exp)) printf("您输入的表达式有误！");break;
case 'b':
while(1)
{
Clear();submenu();
scanf("%c",&c);
switch(c)
{
case '1':add();break;
case '2':multiply();break;
case '3':break;
case '4':exit(1);
default:printf("输入有误！");
}//switch
if(c=='3')break;
}break;
case 'c':Clear();break;
case 'd':exit(1);
default:printf("输入有误！");
}//switch }//while
}//main

Answer 3

去看这个帖子吧，我在那里提供了代码，支持 括号、加、减、乘、除、模、次方、正负号 运算，
可以很方便地增加二元数学运符号。那个是返回 double 的，没有进行公式的正确性校验，也没有四舍五入，楼主就自已解决吧。http://topic.csdn.net/u/20081030/14/0d47d767-0531-4045-9694-6977b93bdba0.html不管有没有参考作用，不用给我分了！收受不起！

Answer 4

项目中常用到这种，我们是解析EXCEL公式成数字再运算的，没你说的这么难吧，代码要的话就贴上来，因我水平一般

Answer 5

你要用到动态编译，antlr致力于这个问题。
下面给你个下载地址
http://www.antlr.org/D00100100/antlr-2.7.1.zip

Answer 6

这里有一段代码，但不是我写的，一起学习一下吧！import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * Java版四则运算器
 * */
public class Calculator { private static Stack OPER; //运算符栈
private static Stack OPND; //运算数栈
private static Vector<String>  vector; //存储数据的容器
private final static char operatortable[][]= { //存储各种运算符的优先级
{'>','>','<','<','<','>','>'},
{'>','>','<','<','<','>','>'},
{'>','>','>','>','<','>','>'},
{'>','>','>','>','<','>','>'},
{'<','<','<','<','<','=','F'},
{'>','>','>','>','F','>','>'},
{'<','<','<','<','<','F','='}
};

Calculator(){
vector =new Vector<String>();
OPER=new Stack();
OPND=new Stack();
} //判断一个字符是否运算符
public  boolean isOperator(String ch){
if(ch.equals("+")||ch.equals("-")||ch.equals("*")||ch.equals("/")||ch.equals("#")||ch.equals("(")||ch.equals(")")){
return true;
}
else
return false;
}

//判断优先级
public char precede(String first, String second){
String [] index={"+","-","*","/","(",")","#"};//用于查找数组序列的一维数组
int firstIndex=0;
int secondIndex=0;
//寻找连个运算符的下标
for(int i=0;i<index.length;i++){
if(index[i].equals(first)){
firstIndex=i;
}
if(index[i].equals(second)){
secondIndex=i;
}
}
return operatortable[firstIndex][secondIndex];
}

//根据运算符计算
public  float Operate(float numberOne, String operator, float numberTwo){
float result=0;
if(operator.equals("+")){
result=numberOne + numberTwo;
}else
if(operator.equals("-")){
result=numberOne - numberTwo;
}else
if(operator.equals("*")){
result=numberOne * numberTwo;
}else
if(operator.equals("/")){
result=numberOne / numberTwo;
}
return result;
} //将字符串格式的运算式存储于Vector中
 public  Vector getExpression(String string){
  //将String类型的字符串转化为char数组
  char[] strArray=new char[string.length()];
  string.getChars(0, string.length(), strArray, 0);
  
  String regexNumber="[\\.\\d]";                    //匹配一个数字或者小数点的正则表达式
  String regexOperator="[\\)\\(\\#\\+\\-\\*/]";       //匹配运算符( +,-,*,/ )的正则表达式
 
  Pattern patternNumber=Pattern.compile(regexNumber); //regexNumber的编译形式
  Pattern patternOperator=Pattern.compile(regexOperator); //regexOperator的编译形式
  
  Matcher matcher=null;  //创建一个匹配器进行模式匹配
  String result="";
  
  int i=0;
  boolean b;
  while(i<strArray.length){
  
   //数组:(1+2)*3
   String s=strArray[i]+"";   //从数组中获取一个字符
  
   matcher=patternOperator.matcher(s);//对运算符进行匹配
   b=matcher.matches();
   
   //判断是否运算符
   if(b){   //如果这个字符是运算符
   //遇到运算符说明前面预遇见的全部是数字，而result中储存的是上一个数字，将其压入arrayList
   if(!result.equals("")){
   vector.add(result);
   }
   result="";   //清空result
 //压入该运算符
   vector.add(s);
   }
   
   matcher=patternNumber.matcher(s);  //首先匹配数字和小数点
   b=matcher.matches();
   //判断是否数字或者小数点
   if(b){   //如果该字符是数字或者小数点
   result=result+s;   //保存到结果中
   }  
   i++;
  }//while()循环
  //最后一个数字之后将不会再遇见运算符
  vector.add(result);
  return vector;
 }
 
     //检查括号是否匹配
 public boolean checkBracket(String str){
 boolean b=true;
 //新建一个用来储存所有括号的栈
 Stack<Character> stack =new Stack<Character>();
 for(int i=0;i<str.length();i++){
 char ch=str.charAt(i);
 //判断括号类型
 switch(ch){
 case '(':{
stack.push(ch);
break;
 }
 case ')':{
 if(stack.isEmpty()){//如果出现')'括号时,栈为空,出现的括号不匹配
 b=false;
 }else{  //如果当前栈中有括号
 if(stack.pop() != '('){//如果当前栈顶不是'('，括号不匹配
 b=false;
 }
 }
 break;
 }
 }//switch
 }
 //所有匹配结束后，栈不空，说明括号不匹配
 if(!stack.isEmpty()){
 b=false;
 }
 return b;
 }

 //检测用户输入的数据是否是:数字+运算符+空格,并且变表达式最后一个字符不可以是运算符
 public boolean checkValue(String str){
 boolean b=false;
 //检测数据的正则表达式
 String regex="[\\d\\+\\-\\*\\/\\)\\(\\s\\.]*";
 //得到正则表达式的编译形式
 Pattern pattern=Pattern.compile(regex);
 //定义匹配器
 Matcher matcher=pattern.matcher(str);
 boolean success=matcher.matches();
 if(success){//如果是正确的数据格式,继续检测表达式最后一个字符是否运算符,')'除外
 int len=str.length();
 char ch=str.charAt(len-1);
 if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('){
 b=false;
 }else{
 b=true;
 }
 }
 return b;
 }
 
//计算
 public float startCalcuate(String opera){
 //vector中存放按序储存的数字和运算符
 vector=getExpression(opera);
 OPER.push("#");
 int i=0;
 String ch=vector.get(i);

 while((!ch.equals("#"))||(!OPER.peek().equals("#"))){
 //System.out.println("取得数据:"+vector.get(i));
 //如果不是运算符
 if(!isOperator(ch)){
 OPND.push(ch);//将数字压入
 i++;
 ch=vector.get(i);
 }else
 {
 switch(precede(OPER.peek().toString(), ch)){
  case '<':
  {
  OPER.push(ch);
  i++;
  ch=vector.get(i);
  break;
  }
  case '=':
  {
  OPER.pop();
  i++;
  ch=vector.get(i);
  break;
  }
  case '>':
  {
  String theta;
  float a,b;
  //获取运算符
  theta=OPER.pop().toString();
  b=Float.parseFloat(OPND.pop().toString());
  a=Float.parseFloat(OPND.pop().toString());
  OPND.push(Operate(a,theta,b));
  break;
  }
 }//switch()
 }
 }//while
 return Float.parseFloat(OPND.peek().toString());
 }
}

Answer 7

这个一千行左右不是我说的，是我们老师说的。我也是刚学一年多，用Java语言搞不定！