四则运算程序-Java程序设计

合集下载

四则运算计算器程序设计(java-GUI)

四则运算计算器程序设计(java-GUI)
四则运算计算器程序设计(java-GUI)
北京林业大学信息学院 闫煜鸿
一、 实例描述
用户通过按钮输入一个四则混合运算表达式,当按下‘=’时能够计算并显示计算结果, 如果用户输入的表达式有错误则要给出 ERROR 提示。
二、 实例分析
本实例需要用户通过按钮输入四则混合运算表达式,那么程序界面需要提供数字和符号 的按钮,同时还需要能够显示输入和输出结果的控件。为了便于布局和管理,使用三个 JButton 数组存放所有的按钮对象,分别为数字键(0 到 9 以及小数点)、运算符键(加、 减、乘、除、括号、等号等)和功能键(包括重置、后退、说明等)。用于显示信息的控件 使用 JLable 类型的对象 lable。
当事件源为‘=’按钮时,除了在 label 后添加字符‘=’,还要调用自定义的方法 EvaluateExpression()得到表达式的值并将此值添加在 lable 之后,同时将 p 的值设为 false。 此时数字键和运算符按钮以及‘后退’键都不可使用。
当事件源为‘重置’按钮时,将 lable 中的字符清空,同时恢复 p 的值为 true。 当事件源为‘说明’按钮时,在 lable 中显示说明文字,同时设置 p 的值为 false,以防 止用户输入的表达式错误。
五、 数据结构与算法设计
如何根据用户输入的字符串表达式计算表达式的值呢?这里介绍使用堆栈来计算表达 式的值的方法。
首先是关于堆栈的描述。使用 java.util 包中的 Stack<E>泛型类可以创建一个堆栈对象。 堆栈对象可以调用 public E push(E item)方法实现入栈操作,及在栈顶插入元素 item;调用 public E pop()方法实现出栈操作,及删除并返回栈顶元素;调用 public boolean empty()方法 判断堆栈是否为空,如果为空则返回 true;调用 public E peek()方法可以获取栈顶元素,但 不删除该元素。在这个程序中需要有两个堆栈对象,分别是用来存放运算数的 OPND 栈(E 为 Float 类型)和存放运算符的 OPTR 栈(E 为 Character 类型)。

java计算器程序代码及文档(带异常处理,括号等。注释详细易懂)

java计算器程序代码及文档(带异常处理,括号等。注释详细易懂)

四则运算计算器设计说明书一.设计目标本次计算器的程序设计,通过使用JA V A中的AWT包和Swing包的类库设计图形界面的计算器。

此计算器能够完成加减乘除的四则混合运算。

利用面向对象程序设计的思想,将各个组件的事件响应分别用不同的方式表达出来,并且使用了图形界面中的事件委托机制来处理事件响应。

二.设计流程1. 分析该计算器需要完成的功能。

用户能够完成添加括号和负号的四则混合运算,并且计算器能够自动识别运算符的优先级,根据用户输入的运算表达式,自动计算出相应的结果。

同时还完成了计算器中C按钮清屏功能和Backspace退格键。

2. 考虑异常处理。

(1)当输入的表达式中出现除零的操作,显示框将显示“Infinity(无穷大)”。

(2)当输入的表达式错误时,将弹出提示框显示“表达式错误请重新输入”(3)当计算器的显示文本框里为没有输入内容时直接点击等号按钮,将弹出提示框显示“对不起,您没有任何输入,请重新输入:”。

(4)当第一次输入乘号键,除号键,右括号,小数点,求余键,等号键,ce 键,Backspace键时提示错误。

4. 考虑数据的处理目标计算表达式通过点击计算器界面上的按钮进行输入,当按下等号之后,计算器通过调用JA V A中script这个包中的相关类和方法来实现数据的处理。

5. 编码实现计算器的功能。

(1)新建相关的文件。

(2)引入JA V A中相关的包。

(3)新建类Jsq,并继承了类Frame,而且实现了接口ActionListener(4)定义相关的变量,创建相关组件,并对组件的属性进行设置。

(5)对所创建的组件进行布局,完成界面的实现。

(6)为各个组件添加事件监听器。

(7)重写事件接口ActionListener的方法public void actionPerformed(ActionEvent e)。

(8)为各个组件编写事件代码,完成每个按钮的不同功能。

三.测试过程的截图1. 程序初始运行界面2运算测试3.混合运算测试:异常处理测试:1.输入错误的表达式2、除数为0时:四.设计结果此计算器以完成设计,所有功能都以实现,并达到了预想的设计目标。

java实现超大整数加减乘除四则运算

java实现超大整数加减乘除四则运算

java实现超⼤整数加减乘除四则运算原理:⽤数组存储数字,按照计算法则进⾏运算。

代码:package com.hdwang;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** ⼤数四则运算(超出long型的⼤数(64位:18446744073709551615))* Created by hdwang on 2017/10/9.*/public class Calculator {/*** 两数相加* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String add(String numStr1, String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;}int[] resultArray = new int[maxLen+1]; //考虑到可能会进位,多给⼀个元素空间//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<minLen;i++){int t = numArray1[i]+numArray2[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<maxLen;i++){int t = maxArray[i]+added; //多余位数加上进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}resultArray[i] = added; //最⾼位//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();for(int n=resultArray.length-1;n>=0;n--){//如果最⾼位为0,移除if(n==resultArray.length-1 && resultArray[resultArray.length-1]==0){continue; //跳过}else{builder.append(resultArray[n]);}}return builder.toString();}/*** 两数相减* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String subtract(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //数值⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;if(numLen1 == numLen2){ //等于maxArray = getMaxNumber(numArray1,numArray2);}}int[] minArray = maxArray==numArray1?numArray2:numArray1; //数值⼩的数int[] resultArray = new int[maxLen];//⼤数-⼩数,同位相减,⼩于0借位int subtracted = 0;int i=0;for(;i<minLen;i++){int t = maxArray[i] - minArray[i] - subtracted; //两数相减,再减借位if(t<0){subtracted = 1; //向⾼位借1,暂存起来resultArray[i] = t+10; //当前位计算结果(借1相当于借了10)}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//⼤数超出部分减掉借位for(;i<maxLen;i++){int t = maxArray[i]-subtracted; //多余位数减掉借位if(t<0){subtracted = 1; //进1resultArray[i] = t+10; //当前位计算结果}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean highBitNotEqualZero = false; //存在⾼位不为0的情况,低位0保留for(int n=resultArray.length-1;n>=0;n--){//如果⾼位为0,移除if(resultArray[n]==0 && !highBitNotEqualZero && n!=0){ //⾼位⽆⽤的0去除continue; //跳过}else{highBitNotEqualZero = true; //找到不为0的位builder.append(resultArray[n]);}}if(maxArray == numArray1){ //第⼀个数⼤或相等}else{ //第⼀个数⼩于第⼆个数,相减为负数builder.insert(0,"-");}return builder.toString();}/*** 两数相乘* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String multiply(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数int[] minArray = null; //长度⼩的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;minArray = numArray1;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;minArray = numArray2;maxArray = numArray1;}//⼆维数组存储结果,例如:23*23 ->[[6,9],[4,6]] ,内部括号(低维)存某位的相乘结果,⾼维低位存个位,⼗位...int[][] resultArray = new int[minLen][maxLen+1];//长度⼤的数*长度⼩的数的每⼀位,分别存到相应数组中,然后累加for(int h=0;h<minLen;h++){ //⾼维int l=0;int added = 0;for(;l<maxLen;l++){ //低维int t = maxArray[l]*minArray[h]+added; //长度⼤的数的每⼀位*长度⼩的数的个位、⼗位...if(t>9){added = t/10; //进位resultArray[h][l] = t%10; //当前位计算结果}else{added = 0; //不进位resultArray[h][l] = t; //当前位计算结果}}resultArray[h][l] = added; //个位、⼗位...的计算结果的最⾼位}//对结果补位(左移),个位不动,⼗位补0,百位补00...,然后累加int[] sum = null; //最终累加结果int[] lowBitResult = null; //低位补0结果(前⼀位)for(int h=0;h<minLen;h++){int[] bitResult = resultArray[h];int[] r; //个位、⼗位...的补0结果if(h==0){ //个位r = bitResult;sum = r;lowBitResult = r; //记录下来,待下次循环累加}else{ //⼗位...的计算结果r = new int[resultArray[h].length+h]; //初始化默认就是0的int rLen = r.length-1;for(int i=bitResult.length-1;i>=0;i--){ //从⾼位开始复制到新数组r[rLen--] = bitResult[i];}//累加之前的数sum = new int[r.length+1]; //取⾼位长度+1,可能进位//================加法核⼼算法====================//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<lowBitResult.length;i++){int t = lowBitResult[i]+r[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<r.length;i++){int t = r[i]+added; //多余位数加上进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}sum[i] = added; //最⾼位//===============================================lowBitResult = sum; //记录下来,待下次循环累加}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean existHighNotZero = false; //⾼位存在不为0的,这个0就不能移除for(int n=sum.length-1;n>=0;n--){//移除⾼位⽆效的0,保留最后⼀个0if(sum[n]==0 && !existHighNotZero && n!=0){continue; //跳过}else{existHighNotZero = true;builder.append(sum[n]);}}return builder.toString();/*** 两数相除* @param numStr1 数1(被除数)* @param numStr2 数2(除数,不能超过long型)* @return结果*/public static String divide(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) long yu = 0;int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){long num = yu * 10 + numArray1[i]; //被除数该位为:余数*10+⾃⼰int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[resultIndex--] = r;}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(yu!=0){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){long num = yu * 10 + 0; //⼩数部分被除数补0int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[decimal--] = r;if(yu==0){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 两数相除(增强版)* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return结果*/public static String divideEnhanced(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) String yu = "0";int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){String num = "0".equals(yu)?numArray1[i]+"":add(yu+"0",numArray1[i]+""); //被除数该位为:余数*10+⾃⼰ DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[resultIndex--] = Integer.parseInt(r); //某位上的结果肯定⼩于10}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(!"0".equals(yu)){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){String num = yu+"0"; //⼩数部分被除数补0DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[decimal--] = Integer.parseInt(r);if("0".equals(yu)){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 校验数字是否合法* @param numStr 数字字符串* @return是否合法*/public static boolean numberValid(String numStr){Pattern pattern = pile("^[1-9]\\d*$|0");Matcher matcher = pattern.matcher(numStr);return matcher.matches();}/*** 计算⼤数* @param numArray1 数1* @param numArray2 数2* @return⼤数*/public static int[] getMaxNumber(int[] numArray1, int[] numArray2) {for(int i=numArray1.length-1;i>=0;i--){if(numArray1[i]>numArray2[i]){return numArray1;}else{if(numArray1[i]==numArray2[i]){continue; //待继续⽐较}else{return numArray2;}}}return numArray1; //全部相等,返回第⼀个}/*** 除法转换为减法* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return除的结果*/public static DivideResult getDivideResult(String numStr1,String numStr2){DivideResult result = new DivideResult();String r = "";// String times = "0";int times = 0; //取整不会⼤于9的(被除数(余数+某位)/除数(肯定⼤于余数)这个过程是,被除数逐渐增⼤到可以除以除数为⽌,此时被除数>=除数,刚刚好,所以被除数最多⽐除数多1位,两数相差肯定⼩于10倍)while (true){r=subtract(numStr1,numStr2);// times = add(times,"1"); //次数递增times++;if("0".equals(r)){ //除尽了result.setYu("0");result.setR(times+"");break;}else if(r.startsWith("-")){ //负数,多减了⼀次result.setYu(numStr1); //上次减下来多余的数值,就是余数// result.setR(subtract(times,"1"));result.setR((times-1)+"");break;}numStr1 = r; //被减数重置为剩余的数值}return result;}}package com.hdwang;/*** Created by hdwang on 2017/10/10.* 相除结果*/public class DivideResult {/*** 取整结果*/private String r;/*** 取余结果*/private String yu;public String getR() {return r;}public void setR(String r) {this.r = r;}public String getYu() {return yu;}public void setYu(String yu) {this.yu = yu;}}package com.hdwang;import java.util.Scanner;import static com.hdwang.Calculator.*;public class Main {public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);boolean loop = true;while (loop) {System.out.println("请输⼊第⼀个⾮负整数:");String numStr1 = scanner.nextLine();if (!numberValid(numStr1)) {System.out.println(String.format("%s不合法", numStr1));continue;}System.out.println("请输⼊第⼆个⾮负整数:");String numStr2 = scanner.nextLine();if (!numberValid(numStr2)) {System.out.println(String.format("%s不合法", numStr2));continue;}String r1 = add(numStr1, numStr2);System.out.println(String.format("⼤数加法计算:%s+%s%s=%s", numStr1, numStr2,r1.length()>50?"\n":"", r1));try {System.out.println("加法直接计算:" + (Long.parseLong(numStr1) + Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("加法直接计算:"+ex.getClass().getName());}String r2 = subtract(numStr1, numStr2);System.out.println(String.format("⼤数减法计算:%s-%s%s=%s", numStr1, numStr2,r2.length()>50?"\n":"", r2));try {System.out.println("减法直接计算:" + (Long.parseLong(numStr1) - Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("减法直接计算:"+ex.getClass().getName());}String r3 = multiply(numStr1, numStr2);System.out.println(String.format("⼤数乘法计算:%s*%s%s=%s", numStr1, numStr2,r3.length()>50?"\n":"", r3));try {System.out.println("乘法直接计算:" + (Long.parseLong(numStr1) * Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("乘法直接计算:"+ex.getClass().getName());}try {String r4 = divide(numStr1, numStr2);System.out.println(String.format("⼤数除法计算:%s/%s%s=%s", numStr1, numStr2, r4.length() > 50 ? "\n" : "", r4)); }catch (Exception ex){System.out.println("⼤数除法计算:"+ex.getClass().getName());}try {System.out.println("除法直接计算:" + ((double)Long.parseLong(numStr1) / (double) Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("除法直接计算:"+ex.getClass().getName());}String r5 = divideEnhanced(numStr1, numStr2);System.out.println(String.format("增强版⼤数除法计算:%s/%s%s=%s", numStr1, numStr2,r5.length()>50?"\n":"", r5)); System.out.println("退出输⼊q,否则继续");String line = scanner.nextLine();if(line.equalsIgnoreCase("Q")){loop = false;}else{loop = true;}}}}运⾏结果:请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:1⼤数加法计算:1+1=2加法直接计算:2⼤数减法计算:1-1=0减法直接计算:0⼤数乘法计算:1*1=1乘法直接计算:1⼤数除法计算:1/1=1除法直接计算:1.0增强版⼤数除法计算:1/1=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:2请输⼊第⼆个⾮负整数:3⼤数加法计算:2+3=5加法直接计算:5⼤数减法计算:2-3=-1减法直接计算:-1⼤数乘法计算:2*3=6乘法直接计算:6⼤数除法计算:2/3=0.6666666666666666除法直接计算:0.6666666666666666增强版⼤数除法计算:2/3=0.6666666666666666退出输⼊q,否则继续请输⼊第⼀个⾮负整数:25请输⼊第⼆个⾮负整数:25⼤数加法计算:25+25=50加法直接计算:50⼤数减法计算:25-25=0减法直接计算:0⼤数乘法计算:25*25=625乘法直接计算:625⼤数除法计算:25/25=1除法直接计算:1.0增强版⼤数除法计算:25/25=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:50⼤数加法计算:100+50=150加法直接计算:150⼤数减法计算:100-50=50减法直接计算:50⼤数乘法计算:100*50=5000乘法直接计算:5000⼤数除法计算:100/50=2除法直接计算:2.0增强版⼤数除法计算:100/50=2退出输⼊q,否则继续请输⼊第⼀个⾮负整数:3请输⼊第⼆个⾮负整数:4⼤数加法计算:3+4=7加法直接计算:7⼤数减法计算:3-4=-1减法直接计算:-1⼤数乘法计算:3*4=12乘法直接计算:12⼤数除法计算:3/4=0.75除法直接计算:0.75增强版⼤数除法计算:3/4=0.75退出输⼊q,否则继续请输⼊第⼀个⾮负整数:4请输⼊第⼆个⾮负整数:3⼤数加法计算:4+3=7加法直接计算:7⼤数减法计算:4-3=1减法直接计算:1⼤数乘法计算:4*3=12乘法直接计算:12⼤数除法计算:4/3=1.3333333333333333除法直接计算:1.3333333333333333增强版⼤数除法计算:4/3=1.3333333333333333退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100⼤数加法计算:1+100=101加法直接计算:101⼤数减法计算:1-100=-99减法直接计算:-99⼤数乘法计算:1*100=100乘法直接计算:100⼤数除法计算:1/100=0.01除法直接计算:0.01增强版⼤数除法计算:1/100=0.01退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:1⼤数加法计算:100+1=101加法直接计算:101⼤数减法计算:100-1=99减法直接计算:99⼤数乘法计算:100*1=100乘法直接计算:100⼤数除法计算:100/1=100除法直接计算:100.0增强版⼤数除法计算:100/1=100退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:10000000000⼤数加法计算:1+10000000000=10000000001加法直接计算:10000000001⼤数减法计算:1-10000000000=-9999999999减法直接计算:-9999999999⼤数乘法计算:1*10000000000=10000000000乘法直接计算:10000000000⼤数除法计算:1/10000000000=0.0000000001除法直接计算:1.0E-10增强版⼤数除法计算:1/10000000000=0.0000000001退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100000000000000000000000000000000000000000000000000⼤数加法计算:1+100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000001加法直接计算:ng.NumberFormatException⼤数减法计算:1-100000000000000000000000000000000000000000000000000=-99999999999999999999999999999999999999999999999999减法直接计算:ng.NumberFormatException⼤数乘法计算:1*100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000000乘法直接计算:ng.NumberFormatException⼤数除法计算:ng.NumberFormatException除法直接计算:ng.NumberFormatException增强版⼤数除法计算:1/100000000000000000000000000000000000000000000000000=0.00000000000000000000000000000000000000000000000001退出输⼊q,否则继续说明:当数字的⼤⼩超过long类型的数值范围时,将⽆法对数值进⾏计算,所以必须实现⼀套算法。

四则运算实现2(JAVA)

四则运算实现2(JAVA)

四则运算实现2(JAVA)之前做了个流程版的,这⾥放最后的总结版先讲功能实现:1.整体程序是个100以内的四则运算出题器;2.做了个选择菜单,你可以⾃由选择需要做加减乘除任意⼀项的四则运算练习;3.增加了内层中的返回功能,使得运⾏过程中不必退出;4.出题器中提供出题,检验答案和揭⽰答案功能。

下⾯是程序实现截图以及代码实现:菜单⾯板:package Live;import java.awt.*;import javax.swing.*;import java.awt.event.*;public class SizeCaidan extends JFrame{JFrame f = new JFrame("运算选择");JPanel p = new JPanel();public SizeCaidan() {JButton b1 = new JButton("加法练习");JButton b2 = new JButton("减法练习");JButton b3 = new JButton("乘法练习");JButton b4 = new JButton("除法练习");JButton ex = new JButton("退出");b1.addActionListener(new Monitor2());b2.addActionListener(new Monitor2());b3.addActionListener(new Monitor2());b4.addActionListener(new Monitor2());ex.addActionListener(new Monitor2());f.addWindowListener(new Wind());f.add(p);p.setLayout(new GridLayout(1, 2));Icon icon=new ImageIcon("src/Live/gdjssfdx.jpg");//JLabel label=new JLabel(icon);label.setBounds(0,0,400,350);f.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));JPanel jp = (JPanel)f.getContentPane();jp.setOpaque(false);//JLabel l = new JLabel();JPanel p2 = new JPanel();p.add(l);p.add(p2);p2.setLayout(new GridLayout(5, 1));p2.add(b1);p2.add(b2);p2.add(b3);p2.add(b4);p2.add(ex);p.setOpaque(false);f.setBounds(200, 200, 400, 400);f.setVisible(true);}public static void main(String[] args) {new SizeCaidan();}private class Wind extends WindowAdapter {public void windowClosing(WindowEvent e) {f.setVisible(false);System.exit(0);}}private class Monitor2 implements ActionListener { @Overridepublic void actionPerformed(ActionEvent e) {if (e.getActionCommand().equals("退出")) {//new SizeCaidan();System.exit(0);}if (e.getActionCommand().equals("加法练习")) {new NumJframe();f.setVisible(false);}if (e.getActionCommand().equals("减法练习")) {new NumJframe2();f.setVisible(false);}if (e.getActionCommand().equals("乘法练习")) {new NumJframe3();f.setVisible(false);}if (e.getActionCommand().equals("除法练习")) {new NumJframe4();f.setVisible(false);}}}}菜单⾯板加法练习⾯板:package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;import Live.JiafaSum;public class Jia_1 {public static void main(String[] args) {new NumJframe();}}class JiafaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的,// 所以采⽤定义类变量的⽅法)public static int sum = 0;}class NumJframe extends JFrame {public NumJframe() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();//返回bank4();//揭⽰答案setTitle("100以內的加法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.yellow);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;JiafaSum.sum = jiashu1 + jiashu2;jt.setText(js1 + "+" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮2jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = JiafaSum.sum;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(JiafaSum.sum+"");}});add(jt4);add(jb4);}}加法以加法为例,其他三则运算也类似,以下直接贴出代码(PS:除法中因为变量提取为int型,所以除法结果也只保留整数部分)package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Jian_1 {public static void main(String[] args) {new NumJframe2();}}class JianfaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum2 = 0;}class NumJframe2 extends JFrame {public NumJframe2() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的减法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.cyan);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jianshu1 = (int) (Math.random() * 100 + 1);int jianshu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jianshu1;String js2 = "" + jianshu2;JianfaSum.sum2 = jianshu1 - jianshu2;jt.setText(js1 + "-" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = JianfaSum.sum2;String inputSum = jt2.getText();// System.out.println("sum="+sum);// System.out.println("inputSum="+inputSum);if (inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null, "答案正确", "消息对话框", RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null, "答案错误", "消息对话框", JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(JianfaSum.sum2+"");}});add(jt4);add(jb4);}}减法package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Cheng {public static void main(String[] args) {new NumJframe3();}}class ChengfaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum3 = 0;}class NumJframe3 extends JFrame {public NumJframe3() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的乘法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.darkGray);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;ChengfaSum.sum3 = jiashu1 * jiashu2;jt.setText(js1 + "X" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = ChengfaSum.sum3;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(ChengfaSum.sum3+"");}});add(jt4);add(jb4);}}乘法package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Chu_1 {public static void main(String[] args) {new NumJframe4();}}class ChufaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum4 = 0;}class NumJframe4 extends JFrame {public NumJframe4() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的除法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.orange);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;ChufaSum.sum4 = jiashu1 / jiashu2;jt.setText(js1 + "÷" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = ChufaSum.sum4;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE);}else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(ChufaSum.sum4+"");}});add(jt4);add(jb4);}}除法以上即为该四则运算的最终代码版。

Java实现四则混合运算代码示例

Java实现四则混合运算代码示例

Java实现四则混合运算代码⽰例使⽤栈来实现,可以处理运算优先级。

使⽤⾃然四则运算表达式即可,如:4+(3*(3-1)+2)/2。

⽆需把表达式先转换为逆波兰等形式。

package com.joshua.cal;import java.util.Collections;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Set;import java.util.Stack;public class Calculator {private final Stack<Double> numStack = new Stack<Double>();private final Stack<Character> opStack = new Stack<Character>();private char currentOperator;private char opStackTop;private int i;private String expression;@SuppressWarnings("rawtypes")public void exec(String expression) {try {clean();if (expression == null || expression.isEmpty()) {throw new IllegalArgumentException("Blank Expression!");}this.expression = expression;opStack.push(TERMINATE_TOKENS.START_END_MARK);List tokens = TOKENIZER.exec(expression+ TERMINATE_TOKENS.START_END_MARK);for (; i < tokens.size(); i++) {final Object token = tokens.get(i);if (token instanceof Double) {processOperand((double) token);} else {processOperator((char) token);}}} catch (Throwable e) {System.err.println(String.format("Incorret Expression: %s\nError: %s", expression,e.getMessage()));}}private void processOperand(final double operand) {numStack.push(operand);}private void processOperator(final char currentOperator) {this.currentOperator = currentOperator;this.opStackTop = opStack.peek();char calMode = CALCULATE_MODE.getRule(currentOperator, opStackTop);switch (calMode) {case '>':processStackHigerPriorityOperator();break;case '<':processStackLowerPriorityOperator();break;case '=':processStackEqualPriorityOperator();break;default:break;}}private void processStackLowerPriorityOperator() {opStack.push(currentOperator);}private void processStackHigerPriorityOperator() {numStack.push(CALCULATE.exec(opStack.pop(), numStack.pop(),numStack.pop()));--i; // pointer back to the previous operator.}private void processStackEqualPriorityOperator() {if (TERMINATE_TOKENS.START_END_MARK == currentOperator) {System.out.println(expression + " = " + numStack.peek());} else if (')' == currentOperator) {opStack.pop();}}public void clean() {numStack.clear();opStack.clear();i = 0;}public static void main(String[] args) {Calculator cal = new Calculator();cal.exec("4+(3*(3-1)+2)/2"); // = 8cal.exec("4 + (-3 * ( 3 - 1 ) + 2)"); // = 0cal.exec("4 +-/ (-3 * ( 3 - 1 ) + 2)"); // incorrect expression!cal.exec("4.5+(3.2+3)/2"); // = 7.6cal.exec("4.5+(3.2:3)/2"); // incorrect expression!cal.exec("-4.5+(3.2-3)/2"); // = -4.4}}enum CALCULATE {INSTANCE;public static double exec(final char operator, final double right,final double left) {switch (operator) {case '+':return left + right;case '-':return left - right;case '*':return left * right;case '/':return left / right;default:throw new IllegalArgumentException("Unsupported operator: "+ operator);}}}enum TERMINATE_TOKENS {INSTANCE;public static final char START_END_MARK = '#';private static final Map<Character, Integer> TOKENs = new HashMap<Character, Integer>(); static {// token, token idTOKENs.put('+', 0);TOKENs.put('-', 1);TOKENs.put('*', 2);TOKENs.put('/', 3);TOKENs.put('(', 4);TOKENs.put(')', 5);TOKENs.put(START_END_MARK, 6);}private static Set<Character> NEGATIVE_NUM_SENSITIVE = new HashSet<Character>(); public static synchronized Set<Character> getNegativeNumSensitiveToken() {if (NEGATIVE_NUM_SENSITIVE.size() == 0) {NEGATIVE_NUM_SENSITIVE.addAll(TOKENs.keySet());NEGATIVE_NUM_SENSITIVE.remove(')');}return NEGATIVE_NUM_SENSITIVE;}public static boolean isTerminateToken(final char token) {Set<Character> keys = TOKENs.keySet();return keys.contains(token);}public static int getTokenId(final char token) {return TOKENs.get(token) == null ? -1 : TOKENs.get(token);}public static int getTokenSize() {return TOKENs.size();}}enum CALCULATE_MODE {INSTANCE;private static char[][] RULES = {// + - * / ( ) #{ '>', '>', '<', '<', '<', '>', '>' }, // +{ '>', '>', '<', '<', '<', '>', '>' }, // -{ '>', '>', '>', '>', '<', '>', '>' }, // *{ '>', '>', '>', '>', '<', '>', '>' }, // /{ '<', '<', '<', '<', '<', '=', 'o' }, // ({ '>', '>', '>', '>', 'o', '>', '>' }, // ){ '<', '<', '<', '<', '<', 'o', '=' }, // #};static {if (RULES.length != TERMINATE_TOKENS.getTokenSize() || RULES.length < 1|| RULES[0].length != TERMINATE_TOKENS.getTokenSize()) {throw new IllegalArgumentException("Rules matrix is incorrect!");}}public static char getRule(final char currentOperator, final char opStackTop) {try {return RULES[TERMINATE_TOKENS.getTokenId(opStackTop)][TERMINATE_TOKENS .getTokenId(currentOperator)];} catch (Throwable e) {throw new RuntimeException("No rules were defined for some token!");}}}enum TOKENIZER {INSTANCE;private static final StringBuilder BUFFER = new StringBuilder();private static String clearExpression(String expression) {return expression.replaceAll(" ", "");}private static Character PREVIOUS_CHAR;private static void clean() {BUFFER.delete(0, BUFFER.length());PREVIOUS_CHAR = null;}private static boolean processNegativeNumbers(final String exp,final int index) {char c = exp.charAt(index);if (('+' == c || '-' == c)&& (PREVIOUS_CHAR == null || TERMINATE_TOKENS.getNegativeNumSensitiveToken().contains(PREVIOUS_CHAR))&& !TERMINATE_TOKENS.isTerminateToken(exp.charAt(index + 1))) {BUFFER.append(c);return true;}return false;}@SuppressWarnings({ "unchecked", "rawtypes" })public static List<?> exec(final String expression) {clean();String exp = clearExpression(expression);List result = new LinkedList();for (int i = 0; i < exp.length(); i++) {char c = exp.charAt(i);if (TERMINATE_TOKENS.isTerminateToken(c)) {if (processNegativeNumbers(exp, i))continue;if (BUFFER.length() > 0) {result.add(Double.valueOf(BUFFER.toString()));BUFFER.delete(0, BUFFER.length());}result.add(c);} else {BUFFER.append(c);}PREVIOUS_CHAR = c;}return Collections.unmodifiableList(result);}}输出4+(3*(3-1)+2)/2 = 8.04 + (-3 * ( 3 - 1 ) + 2) = 0.04.5+(3.2+3)/2 = 7.6-4.5+(3.2-3)/2 = -4.4Incorret Expression: 4 +-/ (-3 * ( 3 - 1 ) + 2)Error: nullIncorret Expression: 4.5+(3.2:3)/2Error: For input string: "3.2:3"总结以上就是本⽂关于实现四则混合运算代码⽰例的全部内容,希望对⼤家有所帮助。

四则运算代码(java版本)采用正则表达式

四则运算代码(java版本)采用正则表达式

四则运算代码(java版本)采⽤正则表达式//加减乘除负数、括号这⼏种//具体看代码以及注释 (测试没发现bug,如发现有bug 请指正)package com.test;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** 四则运算,可能不是最优的写法,⾃⼰测试没发现bug<br>* 前提:正确的算式,因为没做算式的验证<br>* 思路:<br>* 1、⽤正则拆分所有的元素例⼦:2-5+4*5/(2+2)-4<br>* 拆分为【2,-5,4,*,5,/,(,2,2,),-4】<br>* 2、先计算括号⾥,乘除,最后加减** 总结:总体花了17、8个⼩时,主要原因还是没有仔细总体分析流程导致。

<br>* 以⾄于想到点写点代码、修修改改,没有⼀个完整的把握的思路。

所以⼀个问题⼀定<br>* 先⾛通整个思路、流程其实编码是最容易的,重点是处理的过程思路** @author wangshiyan* @time 2014-12-4 下午12:50:01**/public class SizheTool {public static void main(String[] args) {try {System.out.println(jisuanStr("11.2+3.1*(423-(2+5.7*3.4)+5.6)-6.4/(15.5+24)"));} catch (Exception e) {System.out.println("请检查你的算式格式");e.printStackTrace();}}/*** 拆分算式⾥的各个元素并处理对应所在位置<br>** @param str* @return*/public static List<String> splitStr(String string) throws Exception {List<String> listSplit = new ArrayList<String>();Matcher matcher = pile("\\-?\\d+(\\.\\d+)?|[*/()]|\\-").matcher(string);// ⽤正则拆分成每个元素while (matcher.find()) {// System.out.println(matcher.group(0));listSplit.add(matcher.group(0));}return listSplit;}/*** 计算<br>* 步骤:1、如果有括号<br>* 然后取上⼀个最近的(坐标计算当前括号组合⾥的算式),在继续往下查找括号以此类推,直⾄循环使⽤到所有坐标元素* 计算完毕(运算顺序括号、乘除、加减)** @param str* @return*/public static double jisuanStr(String str) throws Exception {double returnDouble = 0;List<String> listSplit = splitStr(str); // 拆分好的元素List<Integer> zKuohaoIdxList = new ArrayList<Integer>();// 左括号,<所在坐标,>if (pile(".*\\(|\\).*").matcher(str).find()) {// 如果包含括号运算String value = "";// 单个字符值int zIdx = 0;// 上⼀个左括号在zKuoHaoIdxList的下标// 此层循环计算完所有括号⾥的算式List<String> tempList = new ArrayList<String>();// 前⾯没有计算的元素int removeL = 0;int tempListSize = 0;for (int i = 0; i < listSplit.size(); i++) {value = listSplit.get(i);tempList.add(value);tempListSize = tempList.size();if ("(".equals(value)) {// 左括号zKuohaoIdxList.add(tempListSize-1);} else if (")".equals(value)) {// 遇到右括号就计算与上⼀左括号间的算式zIdx = zKuohaoIdxList.size() - 1;// 离当前右括号最近的左括号配对int start = zKuohaoIdxList.get(zIdx);returnDouble = jisuan(tempList, start + 1, tempListSize-1); // 开始位置,就是上⼀个左括号 removeL = tempListSize - start;tempList = removeUseList(tempList, removeL);// 移除已使⽤的元素tempList.add(returnDouble + "");// 刚刚计算的值添加进来zKuohaoIdxList.remove(zIdx);// 计算完毕清除括号}}// 把所有计算完returnDouble = jisuan(tempList, 0, tempList.size());} else {// 没有括号运算returnDouble = jisuan(listSplit, 0, listSplit.size());}return returnDouble;}/*** 倒序删除已⽤过的元素** @param list* @param removeLength* 数量* @return*/public static List<String> removeUseList(List<String> list, int removeLength) {int le = list.size() - removeLength;for (int i = list.size() - 1; i >= le; i--) {list.remove(i);}return list;}/*** 计算算式** @param listSplit* @param start* 括号算式开始符位置* @param end* 括号结束符位置* @return*/public static double jisuan(List<String> listSplit, int start, int end)throws Exception {double returnValue = 0;String strValue = null;// 临时变量List<String> jjValueList = new ArrayList<String>();// 剩下的加减元素// 遍历计算乘除法for (int i = start; i < end; i++) {strValue = listSplit.get(i);if ("*".equals(strValue) || "/".equals(strValue)) {// 乘除strValue = jisuanValue("*".equals(strValue) ? "*" : "/", Double.parseDouble(jjValueList.get(jjValueList.size() - 1)),Double.parseDouble(listSplit.get(i + 1)))+ "";jjValueList.remove(jjValueList.size() - 1);i++;}jjValueList.add(strValue);}// 遍历计算加减for (int j = 0; j < jjValueList.size(); j++) {strValue = jjValueList.get(j);if ("-".equals(strValue) || "+".equals(strValue)) {returnValue = jisuanValue("-".equals(strValue) ? "-" : "+",returnValue, Double.parseDouble(jjValueList.get(j + 1)));j++;} else {returnValue += Double.parseDouble(jjValueList.get(j));}}return returnValue;}/*** 计算2个数间的加减乘除操作如:2*5 ,2/5** @param type* 运算符* @param start* 数相当于上⾯2* @param end* 被数相当于上⾯5* @return*/public static double jisuanValue(String type, double start, double end) throws Exception {double d = 0;if ("-".equals(type)) {d = start - end;} else if ("+".equals(type)) {d = start + end;} else if ("*".equals(type)) {d = start * end;} else if ("/".equals(type)) {if (0 == start || 0 == end)d = 0;elsed = start / end;}return d;}}。

Java实现四则运算

Java实现四则运算

Java实现四则运算本次使⽤java语⾔,实现了四则运算习题的⽣成。

⼀、主要功能:(1)算式个数(2)是否有乘除法(3)结果集数值范围(4)加减法有⽆负数(5)除法有⽆余数(6)除法出现⼩数是否⽀持分数显⽰(7)选择⽣成算式导⼊的⽂件(8)输出打印每⾏个数⼆、代码实现:(1)IFormulaGenerationpackage cn.zhl.software;import java.util.Map;public interface IFormulaGeneration {//加法⽣成接⼝,结果范围,加法有⽆负数,⽣成个数public Map<String,Integer> Add(int resultRange,boolean is,int num);//减法⽣成接⼝,结果范围,减法有⽆负数,⽣成个数public Map<String,Integer> Sub(int resultRange,boolean is,int num);//乘法⽣成接⼝,⽣成个数public Map<String,Integer> Mul(int resultRange,int num);//除法⽣成接⼝,结果范围,除法有⽆余数,是否⽀持分数,⽣成个数public Map<String,String> Div(int resultRange,boolean is,boolean is2,int num);//检测算式是否存在重复,如果存在返回truepublic boolean Repeat(Map<?,?> map,String formula);//⽣成特定范围的数值public int nextInt(int min, int max);//算法⽣成器:算式个数,是否有乘除法,数值范围,加减法有⽆负数,除法⼜⽆余数,是否⽀持分数,打印每⾏个数 public Map<String,?> FormulaCustom(int formulaNum,boolean if_MulDiv,int range,boolean ifNeg_AddSub,boolean ifRem_Div,boolean ifRed_Div,int lineNum);}(2)FormulaRealizationpackage cn.zhl.software;import java.util.HashMap;import java.util.Map;import java.util.Random;import java.util.Set;public class FormulaRealization implements IFormulaGeneration {Random random = new Random();@Overridepublic Map<String, Integer> Add(int resultRange, boolean is, int num) {if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> addMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange - r1, resultRange - r1);} else {r2 = nextInt(-r1, resultRange - r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "+" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(addMap, formula)) {}return addMap;}@Overridepublic Map<String, Integer> Sub(int resultRange, boolean is, int num) { if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> subMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange + r1, resultRange + r1);} else {r2 = nextInt(r1, resultRange + r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "-" + (r2 < 0 ? "(" + r2 + ")" : r2); if (Repeat(subMap, formula)) {subMap.put(formula, r1 - r2);n++;}}return subMap;}@Overridepublic Map<String, Integer> Mul(int resultRange, int num) {if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;String formula = "";for (; n < num; ) {while (r1 == 0) {r1 = nextInt(-resultRange, resultRange);}r2 = nextInt(-(int) (resultRange / Math.abs(r1)), (int) (resultRange / Math.abs(r1))); formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "*" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(mulMap, formula)) {mulMap.put(formula, r1 * r2);n++;r1 = nextInt(-resultRange, resultRange);}}return mulMap;}@Overridepublic Map<String, String> Div(int resultRange, boolean is, boolean is2, int num) { if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;}Map<String, String> divMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {//r1 = nextInt(-resultRange, resultRange);while (r2 == 0) {r2 = nextInt(-resultRange, resultRange);}if (!is) {//除法没有余数r1 = r2 * nextInt(-(resultRange), resultRange);} else {//有余数r1 = nextInt(-resultRange, resultRange);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "/" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(divMap, formula)) {String result = "";if (is && is2) {//有余数且化为分数if(r1*r2<0){result = "-"+fracReduction(Math.abs(r1), Math.abs(r2));}else {result = fracReduction(Math.abs(r1), Math.abs(r2));}if(r1%r2==0){result = ((double) r1 / r2) + "";}if (is) {result = ((double) r1 / r2) + "";}}if(r1==0){result=0.0+"";}if (r1==-r2){result="-1.0";}divMap.put(formula, result);n++;}}return divMap;}@Overridepublic boolean Repeat(Map<?, ?> map, String formula) { if (map.isEmpty()) {return true;} else {Set<String> strings = (Set<String>) map.keySet(); for (String string : strings) {//如果当前算式与前⾯算式重复返回falseif (string.equals(formula)) {return false;}}//如果当前算式与前⾯算式不存在重复返回truereturn true;}}@Overridepublic int nextInt(int min, int max) {if (min == max) {return max;}return random.nextInt(max - min + 1) + min;public String fracReduction(int numerator, int denominator) {//找到最⼤公约数,然后分别处以最⼤公约数int m = numerator;int n = denominator;int r;while (numerator > 0) {r = denominator % numerator;denominator = numerator;numerator = r;}// if ((m / denominator)==-(n / denominator)){// return "-1.0";// }return m / denominator + "/" + n / denominator;}@Override//算法⽣成器:算式个数,是否有乘除法,数值范围,加减法有⽆负数,除法⼜⽆余数,是否⽀持分数,打印每⾏个数public Map<String, ?> FormulaCustom(int formulaNum, boolean if_MulDiv, int range, boolean ifNeg_AddSub, boolean ifRem_Div, boolean ifRed_Div, int lineNum) {int add = 0, sub = 0, mul = 0, div = 0;add = nextInt(formulaNum/5,formulaNum/3);sub = nextInt((formulaNum - add)/4,(formulaNum - add)/2);mul = nextInt((formulaNum - add - sub)/3,(formulaNum - add - sub)/1);div = formulaNum - add - sub - mul;Map map = new HashMap();if (if_MulDiv) {//如果存在乘除法将算式总数分为四份Map<String, Integer> addMap = Add(range, ifNeg_AddSub, add);Map<String, Integer> subMap = Sub(range, ifNeg_AddSub, sub);Map<String, Integer> mulMap = Mul(range, mul);Map<String, String> divMap = Div(range, ifRem_Div, ifRed_Div, div);map.putAll(addMap);map.putAll(subMap);map.putAll(mulMap);map.putAll(divMap);} else {//不存在则分为两份map.putAll(addMap);map.putAll(subMap);}return map;}}(3)FormulaRealizationTestpackage cn.zhl.test;import cn.zhl.software.FormulaRealization;import org.junit.Test;import java.util.Map;import java.util.Set;public class FormulaRealizationTest {FormulaRealization formulaRealization = new FormulaRealization();@Testpublic void testAdd() {Map<String, Integer> add = formulaRealization.Add(100, false, 5); for (String s : add.keySet()) {System.out.print(s+"="+add.get(s)+" ");}}@Testpublic void testSub() {Map<String, Integer> sub = formulaRealization.Sub(100, true, 5); for (String s : sub.keySet()) {System.out.print(s+"="+sub.get(s)+" ");}}@TestSystem.out.print(s+"="+mul.get(s)+" ");}}@Testpublic void testDiv() {Map<String, String> div = formulaRealization.Div(100, true, true, 5);for (String s : div.keySet()) {System.out.print(s+"="+div.get(s)+" ");}}@Testpublic void test1() {String div = formulaRealization.fracReduction(25,5);System.out.print(div);}}(4)IFileGenerationpackage cn.zhl.fileCreate;import java.util.Map;public interface IFileGeneration {//⽤于将产⽣的算式写⼊到⽂件中public void fileShow(Map<String,?> stringMap,int lineNum,String fileName); }(5)FileRealizationpackage cn.zhl.fileCreate;import java.io.File;import java.io.FileWriter;import java.io.IOException;@Overridepublic void fileShow(Map<String,?> stringMap, int lineNum, String fileName) {int n=0;String answerName=fileName+"_Answer.txt";fileName=fileName+".txt";/*File file1 = new File("\\cn\\zhl\\formulaFile\\" + fileName);File file2 = new File("\\cn\\zhl\\formulaFile\\" + answerName);*/File file1 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+fileName);File file2 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+answerName);for (String s : stringMap.keySet()) {n++;try(FileWriter formulaWriter = new FileWriter(file1,true); FileWriter answerWriter = new FileWriter(file2,true)) { formulaWriter.write(s+"= ");answerWriter.write(s+"="+stringMap.get(s)+" ");if(n%lineNum==0){formulaWriter.write("\n");answerWriter.write("\n");}} catch (IOException e) {e.printStackTrace();System.out.println("未成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,请联系开发⼈员!"); }}System.out.println("已成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,欢迎您的下次使⽤!"); }}(6)FormulaCustomTestpackage cn.zhl.software;import cn.zhl.fileCreate.FileRealization;import java.io.File;import java.io.FileWriter;import java.io.IOException;public class FormulaCustomTest {public static void main(String[] args) {int formulaNum;boolean if_MulDiv;int range;boolean ifNeg_AddSub;boolean ifRem_Div;boolean ifRed_Div;int lineNum;Scanner scanner = new Scanner(System.in);System.out.println("请输⼊需要算式个数:");formulaNum=scanner.nextInt();System.out.println("请输⼊需要乘除法(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){if_MulDiv=true;}else {if_MulDiv=false;}System.out.println("请输⼊需要结果集范围(默认-n~n):");range=scanner.nextInt();System.out.println("请输⼊允许加减法出现负数(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifNeg_AddSub=true;}else {ifNeg_AddSub=false;}System.out.println("请输⼊允许除法出现⼩数(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRem_Div=true;}else {ifRem_Div=false;}System.out.println("请输⼊允许除法结果换算成分数(Y/N):"); if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRed_Div=true;}else {lineNum=scanner.nextInt();//⽂件名String fileName="";System.out.println("请输⼊算式需要导⼊的⽂件名:");fileName=scanner.next();System.out.println("定制完成,正在随机⽣成算式。

javaweb编写四则运算

javaweb编写四则运算

javaweb编写四则运算⾸先先画出⼀个表<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>四则运算</title></head><form name="a1" action="chuti.jsp" onsubmit="return check(a1);"><h2 align="center">四则运算</h2><table align="center"border="2" width="400"><body><tr><td>你想要的题⽬数量</td><td><input type="text" name="number" value=""placeholder="题数"onchange="checkti(a1)"></td></tr><tr><td>你想要的题⽬的每⾏个数</td><td><input type="text" name="hang" value=""placeholder="⾏数"onchange="checkhang(a1)"></td></tr><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table><script type="text/javascript">function check(a1){var num = a1.number.value;var hang= a1.hang.value;if(num.length==0){alert("题数不能为空");a1.number.value="";a1.number.focus();return false;}if(num.length==0){alert("⾏数不能为空");a1.number.value="";a1.number.focus();return false;}}function checkti(a1){var num = a1.number.value;if(num==""){alert("题数不能为空");a1.number.value="";a1.number.focus();return false;}}function checkhang(a1){var hang=a1.hang.value;if(hang.length==0){alert("⾏数不为空");a1.hang.value="";a1.hang.focus();return false;} 其中运⽤了script语句进⾏脚本判断,来初始判断你输进来的值然后我做了⼀个出题界⾯<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>答题界⾯</title></head><%int h=Integer.parseInt(request.getParameter("hang"));int n=Integer.parseInt(request.getParameter("number"));String value[]=new String[n];String answer[]=new String[n];int i;for(i=0;i<n;){int num1=(int)(1+(Math.random()*100));int num2=(int)(1+(Math.random()*100));int f=(int)(1+(Math.random()*4));if(f==1){value[i]=num1+"+"+num2+"=";answer[i]=num1+num2+"";i++;}else if(f==2&&num1>=num2){value[i]=num1+"-"+num2+"=";answer[i]=num1-num2+"";i++;}else if(f==3&&num1*num2<100){value[i]=num1+"*"+num2+"=";answer[i]=num1*num2+"";i++;}else if(f==4&&num2!=0&&num1%num2==0){value[i]=num1+"/"+num2+"=";answer[i]=num1/num2+"";i++;}elsecontinue;}%><body><h2 align="center">练习题</h2><form action="panduan.jsp"><table align="center"border="2" width="400"><%int k;for(int j=0;j<n;){k=0;%><tr><%while(k<h){%><td><%=value[j] %></td><td><input type="hidden" name="value" value=<%=value[j] %>></td><td><input type="text" name="result" /></td><td><input type="hidden" name="answer" value=<%=answer[j] %>></td> <%j++;k++;if(j>=n)break;}%></tr><%}%><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table></form></body></html> 然后设计⼀个后台来对程序进⾏判断<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>答题界⾯</title></head><%int h=Integer.parseInt(request.getParameter("hang"));int n=Integer.parseInt(request.getParameter("number"));String value[]=new String[n];String answer[]=new String[n];int i;for(i=0;i<n;){int num1=(int)(1+(Math.random()*100));int num2=(int)(1+(Math.random()*100));int f=(int)(1+(Math.random()*4));if(f==1){value[i]=num1+"+"+num2+"=";answer[i]=num1+num2+"";i++;}else if(f==2&&num1>=num2){value[i]=num1+"-"+num2+"=";answer[i]=num1-num2+"";i++;}else if(f==3&&num1*num2<100){value[i]=num1+"*"+num2+"=";answer[i]=num1*num2+"";i++;}else if(f==4&&num2!=0&&num1%num2==0){value[i]=num1+"/"+num2+"=";answer[i]=num1/num2+"";i++;}elsecontinue;}%><body><h2 align="center">练习题</h2><form action="panduan.jsp"><table align="center"border="2" width="400"><%int k;for(int j=0;j<n;){k=0;%><tr><%while(k<h){%><td><%=value[j] %></td><td><input type="hidden" name="value" value=<%=value[j] %>></td><td><input type="text" name="result" /></td><td><input type="hidden" name="answer" value=<%=answer[j] %>></td> <%j++;k++;if(j>=n)break;}%></tr><%}%><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table></form></body></html> 最后⼀个结束界⾯<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>结束界⾯</title></head><body>本次答题结束</body></html>。

Java实现四则运算表达式

Java实现四则运算表达式

四则混合运算的算符优先算法Java实现它们都是对表达式的记法,因此也被称为前缀记法、中缀记法和后缀记法。

它们之间的区别在于运算符相对与操作数的位置不同:前缀表达式的运算符位于与其相关的操作数之前;中缀和后缀同理。

举例:(3 + 4) × 5 - 6 就是中缀表达式- × + 3 4 5 6 前缀表达式3 4 + 5 × 6 - 后缀表达式中缀表达式(中缀记法)中缀表达式是一种通用的算术或逻辑公式表示方法,操作符以中缀形式处于操作数的中间。

中缀表达式是人们常用的算术表示方法。

虽然人的大脑很容易理解与分析中缀表达式,但对计算机来说中缀表达式却是很复杂的,因此计算表达式的值时,通常需要先将中缀表达式转换为前缀或后缀表达式,然后再进行求值。

对计算机来说,计算前缀或后缀表达式的值非常简单。

前缀表达式(前缀记法、波兰式)前缀表达式的运算符位于操作数之前。

前缀表达式的计算机求值:从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素op 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果。

例如前缀表达式“- × + 3 4 5 6”:(1) 从右至左扫描,将6、5、4、3压入堆栈;(2) 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素,注意与后缀表达式做比较),计算出3+4的值,得7,再将7入栈;(3) 接下来是×运算符,因此弹出7和5,计算出7×5=35,将35入栈;(4) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。

可以看出,用计算机计算前缀表达式的值是很容易的。

将中缀表达式转换为前缀表达式:遵循以下步骤:(1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2;(2) 从右至左扫描中缀表达式;(3) 遇到操作数时,将其压入S2;(4) 遇到运算符时,比较其与S1栈顶运算符的优先级:(4-1) 如果S1为空,或栈顶运算符为右括号“)”,则直接将此运算符入栈;(4-2) 否则,若优先级比栈顶运算符的较高或相等,也将运算符压入S1;(4-3) 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较;(5) 遇到括号时:(5-1) 如果是右括号“)”,则直接压入S1;(5-2) 如果是左括号“(”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到右括号为止,此时将这一对括号丢弃;(6) 重复步骤(2)至(5),直到表达式的最左边;(7) 将S1中剩余的运算符依次弹出并压入S2;(8) 依次弹出S2中的元素并输出,结果即为中缀表达式对应的前缀表达式。

javaweb1(小学生四则运算)

javaweb1(小学生四则运算)

javaweb1(⼩学⽣四则运算)⼀、设计思想①设计三个页⾯,分别为题数设置页⾯,题⽬显⽰页⾯以及结果显⽰页⾯。

②设计题数设置页⾯。

③从题数设置页⾯接收题数,作为循环次数。

④利⽤随机数⽣成相应符合条件表达式,并存⼊数据库。

⑤接收⽹页传来的解答,与数据库中的标准答案⽐较,得出成绩。

⼆、源程序代码number.jsp<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>整数⼆级菜单页⾯</title></head><body background="../img/4.jpg"><form name="form1" method=post action="index.jsp"><center> <font color=blue >欢迎来到⼝算练习⽹</font></center><table align="center"><tr><td> <font color=blue >请输⼊需要⽣成的题⽬数量</font></td><td><input name="shuliang" id="shuliang" type="text" > </td></tr></table><center><input type="submit" value="开始出题"> </center></form></body></html>index.jsp<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.sql.Connection,java.sql.DriverManager,java.sql.ResultSet"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>整数页⾯</title></head><body background="../img/5.jpg"><center><font color=green >做题开始了呦!</font></center><%String driverStr = "com.microsoft.sqlserver.jdbc.SQLServerDriver";Class.forName(driverStr).newInstance();String connStr = "jdbc:sqlserver://localhost:1433; DatabaseName=source";String dbusername = "sa";String dbpassword = "123456";Connection conn=null;java.sql.Statement stmt=null;conn=DriverManager.getConnection(connStr, dbusername, dbpassword);stmt=conn.createStatement();int ans=0;String j=request.getParameter("shuliang");int sl=Integer.valueOf(j);String []ss=new String[sl];String s="";String s1="-";String daan[] =new String [sl];String ans2[]=new String[sl];int a[]=new int [sl];int b[]=new int [sl];int a1[]=new int [sl];int b1[]=new int [sl];int a2[]=new int [sl];int flag=0;int flag1=0;int c[]=new int [sl];for(int i=0;i<sl;){daan[i]="name"+i;flag1=0;a[i]=(int)(Math.random()*98+1);b[i]=(int)(Math.random()*98+1);c[i]=(int)(Math.floor((Math.random()*5)));a1[i]=(int)(Math.random()*8+1);b1[i]=(int)(Math.random()*8+1);a2[i]=(int)(Math.random()*98+1);if(c[i]==0){s="+";if(ans<100){ans=a[i]+b[i];ss[i]=a[i]+s+b[i];flag1=1;}}else if(c[i]==1){s="-";if(a[i]>b[i]){ans=a[i]-b[i];ss[i]=a[i]+s+b[i];}else if(a[i]<b[i]){ans=b[i]-a[i];ss[i]=b[i]+s+a[i];}flag1=1;}else if(c[i]==2){s="*";ans=a1[i]*b1[i];ss[i]=a1[i]+s+b1[i];flag1=1;}else if(c[i]==3){s="/";int sum=a1[i]*b1[i];ans=b1[i];ss[i]=sum+s+a1[i];flag1=1;}else{s="+";ans=a[i]+b[i]-a2[i];int sum=a[i]+b[i];if(ans>0&&sum<100){flag1=1;ss[i]=a[i]+s+b[i]+s1+a2[i];}}if(flag1==1){String sql="INSERT INTO size VALUES ('"+ss[i]+"','"+ans+"')";stmt.executeUpdate(sql);ans2[i]=""+ans;out.print(ss[i]);%><br><form name="form2" method="post" action="result.jsp"><font color=green >请输⼊答案<input name=<%=daan[i] %> type="text" id="daan"></font><br/><%i++;session.setAttribute("v1", ss);session.setAttribute("v2", ans2);}}%><input type="submit" value="统计结果"> </form></body></html>result.jsp<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body background="../img/7.jpg"><%String[] s1= (String[])session.getAttribute("v1");String[] answer= (String[])session.getAttribute("v2");String[] daan=new String[s1.length];int count=0;//正确答案的个数for(int i=0;i<s1.length;i++){out.print("运算式为:");out.print(s1[i]+" ");out.print("您的输⼊结果为:");daan[i]=request.getParameter("name"+i);out.print(daan[i]+" ");out.print("正确结果为:");out.print(answer[i]);if(Integer.parseInt(daan[i])==Integer.parseInt(answer[i])){out.print("恭喜你答对了!");count++;}else{out.print("很遗憾,你答错了!");}out.print("<br>");}out.print("你⼀共答对的题⽬数:");out.print(count);%></body></html>三、运⾏结果截图四、编程总结分析这次程序说实话编下来很累很累,因为基本还是⼀窍不通的情况,所以基本⼀切的知识都是⾃⼰查询加上问⼈再⼀个个尝试得出来的。

JAVA四则运算算法

JAVA四则运算算法

JAVA四则运算算法⼀、程序要求解析⼀般数学算式,实现简单的带括号的加减乘除运算。

⼆、基本思路前⾯两篇介绍了直接解析字符串和⽤数组容器辅助解析的两种⽅式,这次再介绍最常⽤的解析算法——解析后缀表达式(逆波兰表达式)。

三、逆波兰表达式及其得到算法1、逆波兰表达式也即后缀表达式,指的是不包含括号,运算符放在两个运算对象的后⾯,所有的计算按运算符出现的顺序,严格从左向右进⾏(不再考虑运算符的优先规则)。

(摘⾃百度),既然没了运算符的优先规则,那么计算机解析起来⾃然容易的多。

对于我们常见的表达式,称为中缀表达式,每个中缀表达式都有对应的后缀表达式。

如:中缀表达式:-2*(1+6/3)+4后缀表达式:-2 1 6 3 / + * 4 +(这⾥为了区分负号和减号,我在数字与数字、数字与符号之间都加了空格,⾄于怎么从中缀表达式得到后缀表达式,后⾯有介绍及参考程序)⽽在解析后缀表达式时,只需要遵守以下原则即可:从左往右遍历遇到数字直接放⼊容器遇到运算符,将最后两个数字取出,进⾏该运算,将结果再放⼊容器遍历结束后,容器中的数字即为运算结果按这个过程⾛下来,⾃然⽽然的想到⽤栈是最合适的。

现只需想办法由输⼊的中缀表达式转为后缀表达式即可完成解析。

2、由中缀表达式得到后缀表达式的算法由中缀表达式得到后缀表达式,只要遵守以下步骤即可:⾸先设置运算符的优先级(这样设置也是为了简化程序):”null” 栈顶若为空,假设优先级为0“(” 优先级设为1“+-” 优先级设为2“*/” 优先级设为3从左向右遍历中缀表达式遇到数字直接输出遇到符号遇到左括号,直接压栈遇到右括号,弹栈输出直到弹出左括号(左括号不输出)遇到运算符,⽐较栈顶符号,若该运算符优先级⼤于栈顶,直接压栈;若⼩于栈顶,弹栈输出直到⼤于栈顶,然后将改运算符压栈。

最后将符合栈弹栈并输出现根据这个原则,⼿动模拟⼀遍转换过程:还是以-2*(1+6/3)+4为例四、代码⼀环境:Eclipse Java EE IDE(Version: Oxygen.1a Release (4.7.1a))jdk1.8.0_131先写⼀个最基本的两位数四则运算⽅法,⽐较简单,没有写注释:private static double doubleCal(double a1, double a2, char operator) throws Exception {switch (operator) {case '+':return a1 + a2;case '-':return a1 - a2;case '*':return a1 * a2;case '/':return a1 / a2;default:break;}throw new Exception("illegal operator!");} 写⼀个获得优先级的⽅法:private static int getPriority(String s) throws Exception {if(s==null) return 0;switch(s) {case "(":return 1;case "+":;case "-":return 2;case "*":;case "/":return 3;default:break;}throw new Exception("illegal operator!");}将中缀表达式转变为后缀表达式:private static String toSufExpr(String expr) throws Exception {System.out.println("将"+expr+"解析为后缀表达式...");/*返回结果字符串*/StringBuffer sufExpr = new StringBuffer();/*盛放运算符的栈*/Stack<String> operator = new Stack<String>();operator.push(null);//在栈顶压⼈⼀个null,配合它的优先级,⽬的是减少下⾯程序的判断/* 将expr打散分散成运算数和运算符 */Pattern p = pile("(?<!\\d)-?\\d+(\\.\\d+)?|[+\\-*/()]");//这个正则为匹配表达式中的数字或运算符Matcher m = p.matcher(expr);while (m.find()) {String temp = m.group();if (temp.matches("[+\\-*/()]")) { //是运算符if (temp.equals("(")) { //遇到左括号,直接压栈operator.push(temp);System.out.println("'('压栈");} else if (temp.equals(")")) { //遇到右括号,弹栈输出直到弹出左括号(左括号不输出)String topItem = null;while (!(topItem = operator.pop()).equals("(")) {System.out.println(topItem+"弹栈");sufExpr.append(topItem+" ");System.out.println("输出:"+sufExpr);}} else {//遇到运算符,⽐较栈顶符号,若该运算符优先级⼤于栈顶,直接压栈;若⼩于栈顶,弹栈输出直到⼤于栈顶,然后将改运算符压栈。

四则运算计算器程序设计javagui

四则运算计算器程序设计javagui

四则运算计算器程序设计(java-gui) 四则运算计算器程序是一种常见的计算机程序,用于执行基本的数学运算,包括加法、减法、乘法和除法。

本文将介绍如何设计一个使用Java GUI实现的四则运算计算器程序。

首先,我们需要创建一个Java GUI窗体,用于显示计算器的界面。

可以使用Java Swing或JavaFX来创建窗体,本文以Java Swing为例。

可以使用JFrame类来创建一个窗体,并添加各种组件,如按钮、标签和文本框等。

在窗体中,我们需要添加一个文本框用于输入表达式和显示结果。

可以使用JTextField类来创建一个文本框,并设置合适的大小和位置。

另外,我们还需要添加一些按钮来表示数字和运算符,可以使用JButton类来创建按钮,并将其添加到窗体中。

接下来,我们需要为按钮添加事件监听器,以便在用户点击按钮时执行相应的操作。

例如,当用户点击数字按钮时,我们需要将相应的数字添加到文本框中;当用户点击运算符按钮时,我们需要将相应的运算符添加到文本框中;当用户点击等号按钮时,我们需要解析文本框中的表达式,并执行相应的运算。

为了实现四则运算,我们可以使用Java的数学库来执行相应的运算。

例如,可以使用Integer.parseInt方法将文本框中的字符串转换为整数,使用加法运算符执行加法运算,使用乘法运算符执行乘法运算等。

在解析和执行表达式时,我们需要考虑一些错误情况,例如除数为零或表达式不合法等。

可以使用try-catch语句来捕获这些异常,并显示相应的错误信息。

最后,我们需要将计算结果显示在文本框中,并提供清除按钮,以便用户可以清除文本框中的内容。

可以使用setText方法将计算结果显示在文本框中,使用setText("")方法来清除文本框中的内容。

综上所述,一个基本的四则运算计算器程序的设计包括创建窗体、添加组件、添加事件监听器、解析和执行表达式、处理异常和显示结果等步骤。

Java实现四则运算的解析收藏

Java实现四则运算的解析收藏
前些天,在项目里面在做OLAP模块,其中一个自定义配置部分,里面需要用到根据配置的四则运算公式(字符串型),计算公式的结果。
于是在网上搜索了一番,终于有所启发。但是也感慨网上很多的例子并不完整,让我冒着访问恶意网页的风险,四处浏览。遂将我自己的实现写在这里,供大家参考讨论。
此实现方法主要是参考了机械工业出版社出版的《数据结构、算法与应用——C++语言描述》(2000年1月出版)当中,第5章——堆栈,第169页,5.5应用——5.5.1括号匹配的例子,使用Java编写完成。
op = operators.get(curPos).charAt(0);
switch (op) {
case '+':
values.add(curPos, values.get(curPos) + values.get(curPos + 1));
values.remove(curPos + 1);
stack.clear();
break;
}else{
System.out.println("有未关闭的右括号!");
isRightFormat = false;
}
}
curPos++;
}
if(stack.size() > 0){
}
}
ArrayList<Double> values = new ArrayList<Double>();
ArrayList<String> operators = new ArrayList<String>();

四则运算二(javaweb)

四则运算二(javaweb)

四则运算⼆(javaweb)最近我和我的⼩伙伴yaoyali结成对⼦,共同写⽹页版的四则运算。

虽然现在还没弄好,但是⽐起上次⽤纯java写的四则运算有了很⼤改进。

⼀.存放四则运算题⽬和答案的类package com.jaovo.msg.model;public class DoubleOperation {private static int operationNumber;private static double[] result;private static String[] question;public static String[] getQuestion() {return question;}public static void setQuestion(String[] question) {DoubleOperation.question = question;}public int getOperationNumber() {return operationNumber;}public void setOperationNumber(int operationNumber) {this.operationNumber = operationNumber;}public double[] getResult() {return result;}public void setResult(double[] result) {this.result = result;}}⼆.Welcom页⾯@charset "UTF-8";/****四则运算题⽬表格(<table>)****/.box{margin-top: 50px;}/****结果输⼊框(<input>)****/.result{width: 60px;padding: 5px;border:none;font-size:20px;border-bottom: solid yellowgreen 5px;text-align:center;}/****题⽬(<td>)****/.expr{font-size: x-large;}/****⾮分数/运算符(<div>)*****/.nomal{text-align:center;float:left;position: relative;top: 16px;margin-left: 3px;margin-right: 3px;width="20px"}/****分数(<div>)****/.fraction{text-align:center;float: left;margin-left:3px;margin-right: 3px;width="20px"}/****题⽬选择*****/.option{text-align: center;}/******你准备好了吗?按钮******/.submit1{padding-top: 10px;padding-bottom: 10px;padding-left: 20px;padding-right: 20px;background: #C90;font-family: "微软雅⿊";font-weight: bold;font-size: 20px;}/*****提交按钮*****/.submit{padding-top: 10px;padding-bottom: 10px;padding-left: 20px;padding-right: 20px;border-radius: 5px;background: cornflowerblue;border: none;cursor: pointer;color:lightyellow;font-family: "微软雅⿊";font-weight: bold;font-size: 20px;}/******计时器*******/.timer{position:fixed;top: 10px;right: 10px;border: none;width:50px;text-align: right;background: none;}.pause{position:fixed;top: 30px;right: 10px;}/****题⽬选项****/.option{margin-left:auto;margin-right:auto;width:600px;margin-top: 130px;border:dashed #9ACD32 2px;padding-top: 100px;padding-bottom: 100px;}/****答题按钮*****/<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><link rel="stylesheet" href="css/style.css"/><title>⼩学⽣四则运算</title><style type="text/css">body{background-image:url(image/2.jpg);}#p1{text - indent:2em;text - align:center;font:italic 35px/40px 幼圆}</style></head><body><p id="p1">欢迎⼩朋友来到⼩猪佩奇的数学乐园,快跟⼩猪佩奇⼀起去冒险吧!</p><form action="choose.jsp" class="option"><button class="submit1" style="margin-top:60px">你准备好了吗?</button></form></body></html>结果截图三.选择出题数量及题⽬种类choose.jsp和Connect.jsp<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><link rel="stylesheet" href="css/style.css"/><title>⼩学⽣四则运算</title><style type="text/css">body{background-image:url(image/4.jpg);}</style></head><body><div style="text-align:right;"><a href="Welcome.jsp">退出</a><br><br></div><form action="Connect.jsp" class="option"><center><h2>题⽬定制</h2></center><p>选择题⽬类型:<select name="elementNum"><option>2</option><option>3</option></select>元运算<br /></p>选择题⽬数量:<input name="count" value="10" type="radio"/>10<input name="count" value="20" type="radio"/>20<input name="count" value="30" type="radio"/>30<input name="count" value="40" type="radio"/>40<input name="count" value="50" type="radio"/>50<input name="count" value="5000" type="radio"/>5000<br/><input name="count" value="1000000" type="radio"/>10000000(极限测试,慎选!!)<br /><br /><button class="submit" style="margin-top:50px">开始答题!</button></form></body></html><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>连接</title></head><body><%String type=request.getParameter("elementNum");String OperationNumber=request.getParameter("count");if(OperationNumber==null||"".equals(OperationNumber)){OperationNumber="10";}if(type.equals("2")){response.sendRedirect("DoubleOperation.jsp?OperationNumber="+OperationNumber);}else{response.sendRedirect("ThreeOperation.jsp?OperationNumber="+OperationNumber);}%></body></html>四.⼆元四则运算DoubleOperation.jsp<%@ page import="java.util.Random" %><%@ page import="ng.Math" %><%@ page import="com.jaovo.msg.model.DoubleOperation" %><%@ page import="java.math.BigInteger" %><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>⼆元运算</title></head><body><form action="doDoubleOperation.jsp" method="post"><div style="text-align:right;"><a href="choose.jsp">题⽬定制</a>&nbsp;&nbsp;<a href="Welcome.jsp">退出</a><br><br></div><%int character=0;//运算符+,-,*,/int num1=0;//运算式中第⼀个数int num2=0;//运算式中第⼆个数int correct=0;//计算正确的数⽬int error=0;//计算错误的数⽬String operat=null;//计算式Random random = new Random();int Endtime=1; //跳转时间int operationNumber=Integer.parseInt(request.getParameter("OperationNumber"));//打印题⽬的数量String question[]=new String[operationNumber];double result[]=new double[operationNumber];//计算式的结果for(int i=0;i<operationNumber;i++)//初始化计算式的结果{result[i]=0;question[i]=null;}DoubleOperation doubleoperation=new DoubleOperation();//初始化.java⽂件中存储的计算公式个数,问题,答案 doubleoperation.setOperationNumber(operationNumber);doubleoperation.setQuestion(question);doubleoperation.setResult(result);for(int i=0;i<operationNumber;i++){character=random.nextInt(4)%4+1;if(character==1)//计算加法{num1=random.nextInt(100)%100;//随机出⼀个0~100的数num2=random.nextInt(100)%100;String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"+"+number2+"=";result[i]=num1+num2;}else if(character==2)//计算减法{num1=random.nextInt(100)%100;//随机出⼀个1~100的数if(num1==0)num1=num1+2;//若num1=0,则加2num2=(int)random.nextInt(num1)%(num1);//随机出⼀个0~num1的数String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"-"+number2+"=";result[i]=num1-num2;}else if(character==3)//计算乘法{num1=random.nextInt(9)%9;//随机出⼀个0~9的数num2=random.nextInt(9)%9;String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"*"+number2+"=";result[i]=num1*num2;}else //计算除法{do{num1=random.nextInt(81)%81;//随机出⼀个0~81的数if(num1>9)num2=random.nextInt(9)%9;else{if(num1==0)num1++;num2=(int)random.nextInt(num1)%(num1);}if(num2==0)//当num2=0再重新⽣成num2{num2=num2+1;}String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"/"+number2+"=";result[i]=num1/num2;}while((result[i]>=10)||(num1%num2!=0));//商为10以内的数}if(Double.valueOf(result[i])>100) {//如果结果⼤于100或⼩数位数⼤于1则不输出i--;}else {question[i]=operat;%><%=operat %><input type="text" name="child_result<%=i %>"><br><br><%}}%><input type="submit" value="提交" name="提交"><%doubleoperation.setOperationNumber(operationNumber);doubleoperation.setQuestion(question);doubleoperation.setResult(result);%><%-- <meta http-equiv="refresh" content ="<%=Endtime*60 %>;url=doDoubleOperation.jsp"> --%> <!-- Endtime分钟后跳转到结果界⾯ --></form></body></html>doDoubleOperation.jsp<%@ page import="com.jaovo.msg.model.DoubleOperation" %><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body><div style="text-align:right;"><a href="choose.jsp">题⽬定制</a>&nbsp;&nbsp;<a href="Welcome.jsp">退出</a><br><br></div><%int correct=0;//计算正确的数⽬int error=0;//计算错误的数⽬int nullerror=0;//没答题的数⽬DoubleOperation doubleoperation=new DoubleOperation();double[] result=doubleoperation.getResult();String[] question=doubleoperation.getQuestion();int operationNumber=doubleoperation.getOperationNumber();System.out.println("count="+operationNumber);for(int i=0;i<operationNumber;i++){String child_result=request.getParameter("child_result"+i);%><%=question[i] %><%=child_result %>&nbsp;&nbsp;&nbsp;<%if((null==child_result)||("".equals(child_result))){nullerror++;%>&nbsp;&nbsp;&nbsp;正确答案是<%=result[i]%><br><br><%}else{double child_result2=Double.valueOf(child_result);if(child_result2==result[i]){correct++;%>√<br><br><%}else{error++;%>×&nbsp;&nbsp;&nbsp;正确答案是<%=result[i]%><br><br><%}}}%><!-- <iframe src='DoubleOperation.jsp'/> -->恭喜你!答对了<%=correct %>道题,答错了<%=error %>道题,没答<%=nullerror %>道题</body></html>四.三元运算ThreeOperation.jsp<%@ page import="java.util.Random" %><%@ page import="ng.Math" %><%@ page import="com.jaovo.msg.model.DoubleOperation" %><%@ page import="java.math.BigInteger" %><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>三元运算</title></head><body><form action="doDoubleOperation.jsp" method="post"><div style="text-align:right;"><a href="choose.jsp">题⽬定制</a>&nbsp;&nbsp;<a href="Welcome.jsp">退出</a><br><br></div><%int character1=0;//第⼀个运算符+,-,*,/int character2=0;//第⼆个运算符int num1=0;//运算式中第⼀个数int num2=0;//运算式中第⼆个数int num3=0;//运算式中的第三个数int correct=0;//计算正确的数⽬int error=0;//计算错误的数⽬String operat=null;//计算式int operationNumber=Integer.parseInt(request.getParameter("OperationNumber"));//打印题⽬的数量String question[]=new String[operationNumber];double result[]=new double[operationNumber];//计算式的结果Random random = new Random();int Endtime=1; //跳转时间for(int i=0;i<operationNumber;i++)//初始化计算式的结果{result[i]=0;question[i]=null;}DoubleOperation doubleoperation=new DoubleOperation();//初始化.java⽂件中存储的计算公式个数,问题,答案 doubleoperation.setOperationNumber(operationNumber);doubleoperation.setQuestion(question);doubleoperation.setResult(result);for(int i=0;i<operationNumber;i++){character1=random.nextInt(4)%4+1;if(character1==1)//计算加法{num1=random.nextInt(100)%100;//随机出⼀个0~100的数num2=random.nextInt(100)%100;String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"+"+number2;result[i]=num1+num2;}else if(character1==2)//计算减法{num1=random.nextInt(100)%100;//随机出⼀个1~100的数if(num1==0)num1=num1+2;//若num1=0,则加2num2=(int)random.nextInt(num1)%(num1);//随机出⼀个0~num1的数String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"-"+number2;result[i]=num1-num2;}else if(character1==3)//计算乘法{num1=random.nextInt(9)%9;//随机出⼀个0~9的数num2=random.nextInt(9)%9;String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"*"+number2;result[i]=num1*num2;}else //计算除法{do{num1=random.nextInt(81)%81;//随机出⼀个0~81的数if(num1>9)num2=random.nextInt(9)%9;else{if(num1==0)num1++;num2=(int)random.nextInt(num1)%(num1);}if(num2==0)//当num2=0再重新⽣成num2{num2=num2+1;}String number1=String.valueOf(num1);String number2=String.valueOf(num2);operat="第("+(i+1)+")题"+number1+"/"+number2;result[i]=num1/num2;}while((result[i]>=10)||(num1%num2!=0));//商为10以内的数}character2=random.nextInt(4)%4+1;if(character2==1)//计算第⼆个加号{num3=random.nextInt(100)%100;String number3=String.valueOf(num3);operat=operat+"+"+num3+"=";result[i]=result[i]+num3;}else if(character2==2)//第⼆个运算符是减号{if(result[i]==0)result[i]=result[i]+2;if(result[i]<100){num3=(int)random.nextInt((int)result[i])%((int)result[i]);//随机出⼀个⼩于被减数的数 }else{num3=random.nextInt(100)%100;}String number3=String.valueOf(num3);operat=operat+"-"+num3+"=";result[i]=result[i]-num3;}else if(character2==3)//乘号{if(character1==2)//若第⼀个运算符是减号,则再随机出来⼀个第⼆个数与第三个随机的数⼩于第⼆个数 num1>=num2*num3 num3<=num1/num2 {if(num2>9){num2=(int)random.nextInt(9)%(9);}if(num1==0)num3=0;else{if(num2==0) num2=num2+1;int num4=num1/num2;num3=(int)random.nextInt(num4)%(num4);}if(num3>9){num3=(int)random.nextInt(9)%(9);}String number3=String.valueOf(num3);operat="第("+(i+1)+")题"+num1+"-"+num2+"*"+num3+"=";result[i]=num1-(num2*num3);}else //第⼀个符号是加乘除。

JAVA四则运算(递归的思想)

JAVA四则运算(递归的思想)

int t = operate.caculate("(3+8*(10-2))"); System.out.println(t); }
}
if (priStack.empty()) { // 当为空时,显然 当前优先级最低,返回高 return true;
} char last = (char) stElement(); // 如果栈顶为'('显然,优先级最低,')'不可能为栈顶。 if (last == '(') {
package demo; import java.util.Stack;
/** * 利用栈,进行四则运算的类 * 用两个栈来实现算符优先,一个栈用来保存需要计算的数据 numStack,一个用来保存计
算优先符 priStack * * 基本算法实现思路为:用当前取得的运算符与 priStack 栈顶运算符比较优先级:若高于,
} // 判断当前运算符与栈顶元素优先级, 如果高,或者低于平,计算完后,将当前操作符号, 放入操作符栈
if (temp.charAt(0) != '#') {
priStack.push(new Character(temp.charAt(0))); if (temp.charAt(0) == ')') {// 当栈顶为'(',而当前元素为')'时,则是括号内以算完,去掉括 号
StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时) StringBuffer string = new StringBuffer().append(str);// 用来保存,提高效率 while (string.length() != 0) {

小学生四则运算(java编程)201571030135

小学生四则运算(java编程)201571030135

⼩学⽣四则运算(java编程)201571030135任务1源码在Github的仓库主页链接地址:需求分析:1. 作业总体效果:随机产⽣n道加减乘除练习题;2. 练习题的构成:数字和运算符且每个数字在 0 和 100 之间,运算符在3个到5个之间且每个练习题⾄少要包含2种运算符;3. 练习题的结果:练习题在运算过程中不出现负数与⾮整数;4. 最终提交结果:学号与⽣成的n道练习题及其对应的正确答案;样例如下:功能设计:1. 表达式的⽣成模块。

⾸先需要⽣成运算符与数字,每个等式中运算符的个数加⼀就等于该等式中的数字个数,之后将⽣成的符号与数字组合成String,传⼊逆波兰计算模块进⾏结果的输出。

在此模块中将除法中分母为零的情况、运算符只有⼀种的情况以及分⼦分母除不尽的情况排除。

2. 表达式的计算模块。

利⽤逆波兰表达式计算结果,在该模块中排除例如30/6/3这样的情况,在之前的模块中排除的只是除号前后的分⼦分母的情况,并未考虑除号连续的情况,当除号连续时,需要考虑第⼀个除号运算完之后的结果能否继续除以下⼀个数的情况,当遇到前后余数不为0的情况以及中间结果为负数的情况就跳出该函数,继续产⽣新的等式直⾄满⾜条件。

写这个模块的时候借鉴这位博主的写法();3. 结果写⼊⽂件模块。

将⾃⼰的学号与根据⽤户输⼊的题⽬个数⽣成的等式写⼊⽂件。

4. 异常情况的处理。

排除输⼊为⾮数字的情况以及输⼊的数字⼤于1000、⼩于1以及等于0的情况。

基本功能:实现每道练习题运算符在3个到5个之间,⾄少要包含2种运算符;运算结果⽆负数以及⾮整数;将最终结果保存在⽂档中以样例为模板;每道练习题的结果不超过⼀定的范围(考虑到⼩学⽣计算能⼒有限,当时问了郑⽼师,在⽼师的提⽰下,设置了⽤户输⼊想要⽣成结果的范围这⼀块内容,并进⾏了异常处理)。

设计实现:利⽤Visio进⾏流程图的绘制,具体流程图如下:其中ContentToTxt(将结果写⼊⽂件) Main(主程序可以从命令⾏接收参数) ReversePolish (逆波兰表达式) RandomEquation(产⽣等式) result.txt(运⾏后产⽣的结果)测试运⾏:核⼼代码:1)随机产⽣等式模块:为了看起来整洁,去掉了测试过程中注释掉的打印输出部分。

用java具体代码实现分数(即有理数)四则运算

用java具体代码实现分数(即有理数)四则运算

⽤java具体代码实现分数(即有理数)四则运算⽤java具体代码实现分数(即有理数)四则运算1,背景Java⽼师布置了⼀个关于有理数运算的题⽬,因为参考书上有基本代码,所以⾃⼰主要是对书上代码做了⼀点优化,使其⽤户交互性更加友好以及代码封装性更强2,说明:分数也称作有理数,是我们很熟悉的⼀种数。

有时希望程序能对分数进⾏四则运算,⽽且两个分数四则运算的结果仍然是分数。

下⾯是具体实现3,java代码具体实现3.1 运算类封装package Rational;import java.util.StringTokenizer;/*** @author sunkun* 分数四则运算*/public class Calculator {int numerator; // 分⼦int denominator; // 分母Calculator(){}Calculator(int a,int b){if(a == 0){numerator = 0;denominator = 1;}else{setNumeratorAndDenominator(a,b);}}void setNumeratorAndDenominator(int a, int b){ // 设置分⼦和分母int c = f(Math.abs(a),Math.abs(b)); // 计算最⼤公约数numerator = a / c;denominator = b / c;if(numerator<0 && denominator<0){numerator = - numerator;denominator = - denominator;}}int getNumerator(){return numerator;}int getDenominator(){return denominator;}int f(int a,int b){ // 求a和b的最⼤公约数if(a < b){int c = a;a = b;b = c;}int r = a % b;while(r != 0){a = b;b = r;;r = a % b;}return b;}Calculator add(Calculator r){ // 加法运算int a = r.getNumerator();int b = r.getDenominator();int newNumerator = numerator * b + denominator * a;int newDenominator = denominator * b;Calculator result = new Calculator(newNumerator,newDenominator);return result;}Calculator sub(Calculator r){ // 减法运算int a = r.getNumerator();int b = r.getDenominator();int newNumerator = numerator * b - denominator * a;int newDenominator = denominator * b;Calculator result = new Calculator(newNumerator,newDenominator);return result;}Calculator muti(Calculator r){ // 乘法运算int a = r.getNumerator();int b = r.getDenominator();int newNumerator = numerator * a;int newDenominator = denominator * b;Calculator result = new Calculator(newNumerator,newDenominator);return result;}Calculator div(Calculator r){ // 除法运算int a = r.getNumerator();int b = r.getDenominator();int newNumerator = numerator * b;int newDenominator = denominator * a;Calculator result = new Calculator(newNumerator,newDenominator);return result;}// 封装了具体运算,主要为对输⼊进⾏转换,对输出封装public static void compute(String data1,String operation,String data2){ StringTokenizer fenxi = new StringTokenizer(data1,"/");int data1_1 = Integer.parseInt(fenxi.nextToken());int data1_2 = Integer.parseInt(fenxi.nextToken());fenxi = new StringTokenizer(data2,"/");int data2_1 = Integer.parseInt(fenxi.nextToken());int data2_2 = Integer.parseInt(fenxi.nextToken());Calculator r1 = new Calculator(data1_1,data1_2);Calculator r2 = new Calculator(data2_1,data2_2);Calculator result;int a,b;if(operation.equals("+")){result = r1.add(r2);a = result.getNumerator();b = result.getDenominator();System.out.println(data1+" "+operation+" " +data2+" = " + a + "/" + b); }if(operation.equals("-")){result = r1.sub(r2);a = result.getNumerator();b = result.getDenominator();System.out.println(data1+" "+operation+" " +data2+" = " + a + "/" + b); }if(operation.equals("*")){result = r1.muti(r2);a = result.getNumerator();b = result.getDenominator();System.out.println(data1+" "+operation+" " +data2+" = " + a + "/" + b); }if(operation.equals("/")){result = r1.div(r2);a = result.getNumerator();b = result.getDenominator();System.out.println(data1+" "+operation+" " +data2+" = " + a + "/" + b); }}}3.2 测试类package Rational;import java.util.Scanner;/*** @author sunkun* 为了测试分数四则运算* */public class TestCal {public static void main(String[] args) {// TODO Auto-generated method stub// ⽤户输⼊两分数和运算符Scanner input = new Scanner(System.in);System.out.println("请⽤户输⼊第⼀个分数(格式a/b)");String data1 = input.next();System.out.println("请⽤户输⼊要进⾏运算的运算符(+-*/)");String operation = input.next();System.out.println("请⽤户输⼊第⼆个分数(格式c/d)");String data2 = input.next();// 根据⽤户输⼊进⾏具体运算Calculator cal = new Calculator();System.out.println("运算结果为:");pute(data1, operation, data2);// }}}4,实验结果5,备注如果您有更好的想法或建议,欢迎留⾔,⼤家共同学习,相互提⾼。

java 请分数类的四则运算

java 请分数类的四则运算

java 请分数类的四则运算Java是一种面向对象的编程语言,它提供了丰富的类和方法来实现各种功能。

在数学中,四则运算是最基本的运算,包括加法、减法、乘法和除法。

本文将以Java编写一个分数类,并实现分数的四则运算。

我们需要定义一个分数类,这个类包含两个成员变量:分子和分母。

分子表示分数的上部分,分母表示分数的下部分。

我们还需要提供一个构造方法,用于初始化分子和分母的值。

以下是分数类的代码实现:```javapublic class Fraction {private int numerator; // 分子private int denominator; // 分母public Fraction(int numerator, int denominator) {this.numerator = numerator;this.denominator = denominator;}// 省略getter和setter方法}```接下来,我们需要实现分数的四则运算。

首先是加法运算。

我们可以通过通分的方式将两个分数相加,然后将分子相加得到新的分子,分母保持不变。

最后,我们需要对结果进行约分,即将分子和分母的最大公约数约去。

以下是加法运算的代码实现:```javapublic Fraction add(Fraction other) {int newNumerator = this.numerator * other.denominator + other.numerator * this.denominator;int newDenominator = this.denominator * other.denominator;int gcd = gcd(newNumerator, newDenominator); // 求最大公约数return new Fraction(newNumerator / gcd, newDenominator / gcd);}// 辅助方法,求两个数的最大公约数private int gcd(int a, int b) {if (b == 0) {return a;}return gcd(b, a % b);}```接下来是减法运算。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《程序设计实践》题目:小学生四则运算练习程序
学校:
学院:
班级:
学号:
姓名:_
2014 年11月24 日
实践基础程序设计实践
一、实践目的
1、掌握基本输入输出。

2、掌握方法定义与调用,理解参数传递方式。

二、实践要求
利用方法、数组、基本输入输出等Java基础知识,给出所选项目的基本设计与实现。

三、项目需求
所选项目名称:小学生四则运算练习程序
实现对小学生简单加法、减法、乘法、除法的四则运算练习。

要求通过键盘输入两个运算数,并回显输入数,将运算结果输出。

四、项目设计方案
Test类:
数据域:sum,总分数。

方法:core()负责随机生成题目,并对其打上分数。

main(String[] args)是程序的入口,负责程序的开始。

五、核心算法详细设计
1.public static void main(String[] args) {
Test t = new Test();
// 提示用户考试信息
System.out.println("本次测试共十道题,每题十分,满分一百分");
// 将分数sum初始化为0;
t.sum = 0;
// 创建一个随机类
Random r = new Random();
// 进行10个循环,对应着10道题
for (int i = 0; i < 10; i++) {
t.core();
}
//打印出考试成绩
System.out.println(" 考试结束");
System.out.println(" 您的总分为" + t.sum);
}
2.//考试的题目。

private void core() {
//产生一个随即生成器
Random r = new Random();
//产生一个在0,1,-1之中的数
int m, n;
m = r.nextInt() % 10;
n = m % 2;
六、完整源码
package test;
import java.util.Random;
import java.util.Scanner;
public class Test {
int sum;
public static void main(String[] args) {
Test t = new Test();
// 提示用户考试信息
System.out.println("本次测试共十道题,每题十分,满分一百分");
// 将分数sum初始化为0;
t.sum = 0;
// 创建一个随机类
Random r = new Random();
// 进行10个循环,对应着10道题
for (int i = 0; i < 10; i++) {
t.core();
}
//打印出考试成绩
System.out.println(" 考试结束");
System.out.println(" 您的总分为" + t.sum);
}
//考试的题目。

private void core() {
//产生一个随即生成器
Random r = new Random();
//产生一个在0,1,-1之中的数
int m, n;
m = r.nextInt() % 10;
n = m % 2;
switch (n) {
//如果n为-1,则进行加法运算
case -1:
int a,b,c;
//a为操作数,b为被操作数,都是10以内的数字。

a = r.nextInt() % 10;
b = r.nextInt() % 10;
//给出运算式,让用户输入答案
System.out.println(a + "+" + "(" + b + ")=?");
Scanner x = new Scanner(System.in);
c = x.nextInt();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (c != a + b)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
//如果n为0,则进行乘法运算
case 0:
int q,w,e;
//q为操作数,w为被操作数,都是10以内的数字。

q = r.nextInt() % 10;
w = r.nextInt() % 10;
//给出运算式,让用户输入答案
System.out.println(q + "*" + "(" + w + ")" + "=?");
Scanner y = new Scanner(System.in);
e = y.nextInt();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (e != q * w)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
//如果n为1,则进行除法运算
case 1:
double j,k,l;
//j为操作数,k为被操作数,都是10以内的数字。

j = r.nextInt() % 10;
k = r.nextInt() % 10;
//k作为被除数不能为0
if (k == 0)
k++;
//给出运算式,让用户输入答案
System.out.println(j + "/" + "(" + k + ")" + "=?");
Scanner z = new Scanner(System.in);
l = z.nextDouble();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (l != (j / k) / 1.00)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
}
}
}
七、使用说明与运行结果截图
1.运行程序,出现提示页面,弹出第一个题目
2.
2.输入结果“-1”,单击回车,提示回答正确,弹出下一题
3.输入结果“-5”,单击回车,提示正确,弹出下一题
4.输入错误答案“53”,提示错误
5.输入结果“7”,单击回车,弹出下一题。

6.继续做题,直到完成10道计算,在此不一一阐述
7. 当10道题目做完结束后,显示最终成绩
八、实践总结
本次实践是第一次实践,自己的基本功不扎实就更要努力了,老师说了这个学期的实践对于自己的动手能力和以后的学习都很有帮助,所以我也下定决心好好学,这个程序自己打的很累,其中张昊给了我很大的帮助,结果还算满意,不过还有不足,也希望自己能够在今后越做越好,能够提高自己,也希望老师能更加督促我,成绩能有一个大的进步。

[此文档可自行编辑修改,如有侵权请告知删除,感谢您的支持,我们会努力把内容做得更好]。

相关文档
最新文档