简单的JAVA四则运算
JAVA_实现两个复数的四则运算
JAVA_实现两个复数的四则运算1、⼀个复数类Complex由两部分组成：实部real和虚部imaginary，两个复数可以进⾏加减乘除四则运算。
试设计这个复数类，然后在另⼀个类的程序⼊⼝演⽰。
public class Test {public static void main(String[] args) {// 定义两个对象并赋值：c1(a+bi)=(2+4i),c2=(c+di)=(6+16i)Complex c1=new Complex();c1.real=2;c1.imaginary=4;Complex c2=new Complex();c2.real=6;c2.imaginary=16;// 以字符串的⽅式输出：采⽤标准格式输出，即a+biSystem.out.println("两个复数相加得："+c1.add(c2));// 在每次调⽤并运算（此时real值发⽣变化）之后，再重新赋值：c1.real=2;c1.imaginary=4;System.out.println("两个复数相减得："+c1.sub(c2));c1.real=2;c1.imaginary=4;System.out.println("两个复数相乘得："+c1.mul(c2));c1.real=2;c1.imaginary=4;System.out.println("两个复数相除得："+c1.div(c2));}}class Complex{double real;double imaginary;//最后以字符串输出的格式：//1.虚部为正值时，实部+"+"+虚部+"i" 2.虚部为0时，只有实部，即实部+"" 3.虚部为负值时，实部+""+虚部+"i" // 加法，减法：直接实部加减实部，虚部加减虚部String add(Complex c){if(imaginary+c.imaginary>0)return (real=real+c.real)+"+"+(imaginary=imaginary+c.imaginary)+"i";else if(imaginary+c.imaginary==0)return (real=real+c.real)+"";elsereturn (real=real+c.real)+""+(imaginary=imaginary+c.imaginary)+"i";}String sub(Complex c){if(imaginary-c.imaginary>0)return (real=real-c.real)+"+"+(imaginary=imaginary-c.imaginary)+"i";else if(imaginary-c.imaginary==0)return (real=real-c.real)+"";elsereturn (real=real-c.real)+""+(imaginary=imaginary-c.imaginary)+"i";}// 乘法的公式：(a+bi)*(c+di) = a*c + bi*c + a*di + bi*di = a*c + (b*d)(i^2) + (b*c+a*d)i// 注：此处的i^2直接赋值-1，即 return a*c-b*d+(b*c+a*d)iString mul(Complex c){if(imaginary*c.real+real*c.imaginary>0)return (real*c.real)-(imaginary*c.imaginary)+"+"+(imaginary*c.real+real*c.imaginary)+"i";else if(imaginary*c.real+real*c.imaginary==0)return (real*c.real)-(imaginary*c.imaginary)+"";elsereturn (real*c.real)-(imaginary*c.imaginary)+""+(imaginary*c.real+real*c.imaginary)+"i";}// 除法的公式：(a+bi)/(c+di) = (a+bi)*(c-di) / c^2+d^2// 注：在乘法的基础上得到格式A+Bdi，再进⾏A /c^2+d^2，B /c^2+d^2 + "i"String div(Complex c){if(imaginary*c.real-real*c.imaginary>0)return ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+"+"+(imaginary*c.real-real*c.imaginary)/(c.real*c.real+c.imaginary*c.imaginary)+"i";else if(imaginary*c.real-real*c.imaginary==0)return ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+"";elsereturn ((real*c.real)+(imaginary*c.imaginary))/(c.real*c.real+c.imaginary*c.imaginary)+""+(imaginary*c.real-real*c.imaginary)/(c.real*c.real+c.imaginary*c.imaginary)+"i";}}/*Complex c1=new Complex();c1.real=2;c1.imaginary=4;Complex c2=new Complex();c2.real=6;c2.imaginary=16;即：c1=2+4ic2=6+16i数学运算结果：两者相加：8+20i两者相减：-4-12i两者相乘：-52+56i(2+4i)*(6+16i)两者相除：0.2602739726027397-0.0273972602739726i(2+4i)/(6+16i)=(2+4i)*(6-16i)/(6*6+16*16)*/。
java解析四则运算为树形的方法_概述及解释说明
java解析四则运算为树形的方法概述及解释说明1. 引言1.1 概述：本文将讨论Java解析四则运算为树形结构的方法。
四则运算是数学中最基础的运算，包括加法、减法、乘法和除法。
通过对四则运算表达式进行解析，可以将其转化为树形结构，以提供更方便的处理和计算方式。
在本文中，我们将介绍四则运算及其解析方式的简介，并重点关注树形结构在这种解析中的应用。
1.2 文章结构：本文共分为5个部分：引言、正文、解释说明、结论和后记。
在引言部分，我们将给出文章的概述，简述整篇文章的内容与目标。
在正文部分，我们将详细介绍四则运算及其解析方式的简介，并探究树形结构在这种解析中的作用。
在解释说明部分，我们会阐述将四则运算表达式转化为树形结构的基本概念和原理，并讨论Java中实现这一过程的方法。
接着，我们还会探讨树形结构在四则运算解析中的优势和应用场景。
在结论部分，我们将总结文章要点和重点论述内容，并对Java解析四则运算为树形的方法进行评价并展望未来的发展方向。
最后，在后记部分，我们将留下一些附加信息和感想。
1.3 目的：本文的目的是提供一个全面且易懂的解析四则运算为树形结构的方法，并探讨这种方法在Java中的应用。
通过深入了解四则运算的解析和树形结构的应用，读者可以更好地理解并使用这些技术，进一步提高程序设计和算法实现能力。
本文还旨在为Java开发者提供一个可靠而有效的工具，以便于他们处理复杂的四则运算表达式。
跟随本文学习并实践这种方法可以增强编码技巧和培养抽象思维能力，在日常开发中收获不少益处。
2. 正文:2.1 四则运算及其解析方式简介:在数学中，四则运算指的是加法、减法、乘法和除法这四种基本运算。
它们是最常见和基础的数学运算，广泛应用于各个领域。
在计算机科学中，我们通常需要将四则运算表达式进行解析，以便计算机能够理解和执行。
2.2 树形结构在四则运算解析中的应用:树形结构是一种非常适合表示嵌套层次关系的数据结构。
java随机出题四则运算
java随机出题四则运算要实现Java随机出题四则运算，我们可以使用Random类来生成随机数，然后结合算术表达式来生成题目。
下面是一个简单的实现示例：java.import java.util.Random;public class RandomArithmetic {。
public static void main(String[] args) {。
Random random = new Random();int num1 = random.nextInt(100); // 生成0-99之间的随机数作为操作数1。
int num2 = random.nextInt(100); // 生成0-99之间的随机数作为操作数2。
char[] operators = {'+', '-', '', '/'};char operator = operators[random.nextInt(4)]; // 生成随机的运算符。
// 生成题目。
String question = num1 + " " + operator + " " + num2 + " = ?";System.out.println("题目，" + question);// 计算结果。
double result = 0;switch (operator) {。
case '+':result = num1 + num2;break;case '-':result = num1 num2;break;case '':result = num1 num2;break;case '/':result = (double) num1 / num2; // 避免整数除法。
关于java中BigDecimal数据类型的四则运算
关于java中BigDecimal数据类型的四则运算构造器描述 BigDecimal(int)创建⼀个具有参数所指定整数值的对象。
BigDecimal(double)创建⼀个具有参数所指定双精度值的对象。
BigDecimal(long)创建⼀个具有参数所指定长整数值的对象。
BigDecimal(String)创建⼀个具有参数所指定以字符串表⽰的数值的对象。
BigDecimal(int)创建⼀个具有参数所指定整数值的对象。
BigDecimal(double)创建⼀个具有参数所指定双精度值的对象。
BigDecimal(long)创建⼀个具有参数所指定长整数值的对象。
BigDecimal(String)创建⼀个具有参数所指定以字符串表⽰的数值的对象⽅法描述 add(BigDecimal)BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal)BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal)BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal)BigDecimal对象中的值相除，然后返回这个对象。
toString()将BigDecimal对象的数值转换成字符串。
doubleValue()将BigDecimal对象中的值以双精度数返回。
floatValue()将BigDecimal对象中的值以单精度数返回。
longValue()将BigDecimal对象中的值以长整数返回。
intValue()将BigDecimal对象中的值以整数返回。
add(BigDecimal)BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal)BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal)BigDecimal对象中的值相乘，然后返回这个对象。
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 {//遇到运算符，⽐较栈顶符号，若该运算符优先级⼤于栈顶，直接压栈；若⼩于栈顶，弹栈输出直到⼤于栈顶，然后将改运算符压栈。
Java实现四则运算的解析收藏
于是在网上搜索了一番，终于有所启发。但是也感慨网上很多的例子并不完整，让我冒着访问恶意网页的风险，四处浏览。遂将我自己的实现写在这里，供大家参考讨论。
此实现方法主要是参考了机械工业出版社出版的《数据结构、算法与应用——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>();
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 加减乘除方法
（原创实用版4篇）编辑人员:_______________审核人员:_______________审批人员:_______________编辑单位:_______________编辑时间:____年___月___日序言小编为大家精心编写了4篇《java 加减乘除方法》，供大家借鉴与参考。
下载后，可根据实际需要进行调整和使用，希望对大家有所帮助。
（4篇）《java 加减乘除方法》篇1在 Java 中，加减乘除的方法可以通过创建一个名为`Calculator`的类来实现。
以下是一个简单的示例：```javapublic class Calculator {public static void main(String[] args) {double num1 = 5.5;double num2 = 2.5;double result = calculate(num1, num2);System.out.println("结果：" + result);}public static double calculate(double num1, double num2) {double result = 0;if (Math.random() < 0.5) {result = num1 + num2;} else {result = num1 - num2;}return result;}}在这个示例中，我们创建了一个名为`Calculator`的类，并在其中定义了一个名为`calculate`的方法。
该方法接受两个参数，分别是两个 double 类型的数字，并根据随机数生成器的结果决定执行加法或减法操作。
《java 加减乘除方法》篇2在 Java 中，加减乘除的方法可以通过创建一个名为`Calculator`的类来实现。
以下是一个简单的示例：```javapublic class Calculator {public static void main(String[] args) {double num1 = 5.5;double num2 = 2.5;double result = calculate(num1, num2);System.out.println("结果为：" + result);}public static double calculate(double num1, double num2) {double result = 0;if (Math.random() < 0.5) {result = num1 + num2;} else {result = num1 - num2;}return result;}```在这个示例中，我们创建了一个名为`Calculator`的类，并在其中定义了一个名为`calculate`的方法。
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"总结以上就是本⽂关于实现四则混合运算代码⽰例的全部内容，希望对⼤家有所帮助。
有限域gf(2^8)的四则运算java代码
有限域gf(2^8)的四则运算java代码有限域（Finite Field），也称为伽罗瓦域（Galois Field），是一个具有有限个元素的数学结构。
在有限域中进行四则运算，最常见的是GF(2^8)有限域，它由2的8次方个元素组成。
在Java中，可以使用位运算和多项式运算的方式来实现有限域的四则运算。
首先，我们需要定义有限域GF(2^8)中的所有元素。
每个元素可以表示为一个8位的二进制数，所以可以用一个字节（byte）类型来表示。
下面是一个简单的定义有限域元素的类：```javapublic class FiniteFieldElement {private byte value;public FiniteFieldElement(byte value) {this.value = value;}public byte getValue() {return value;}}```在有限域中，加法操作定义为两个元素进行异或（XOR）运算，即按位相加，不进位。
下面是定义有限域加法操作的方法：```javapublic static FiniteFieldElement add(FiniteFieldElement a, FiniteFieldElement b) {return new FiniteFieldElement((byte)(a.getValue() ^b.getValue()));}```同样地，减法操作也可以用异或运算实现，即按位相减，不退位：```javapublic static FiniteFieldElementsubtract(FiniteFieldElement a, FiniteFieldElement b) { return new FiniteFieldElement((byte)(a.getValue() ^b.getValue()));}```有限域中的乘法操作可以理解为两个元素进行位运算，并使用指定的多项式进行模运算。
Java四则运算
Java四则运算public class Demo04Operator {public static void main(String[] args) {// 两个常量之间可以进⾏数学运算System.out.println(20 + 30);// 两个变量之间也可以进⾏数学运算int a = 20;int b = 30;System.out.println(a - b); // -10// 变量和常量之间可以混合使⽤System.out.println(a * 10); // 200int x = 10;int y = 3;int result1 = x / y;System.out.println(result1); // 3int result2 = x % y;System.out.println(result2); // 余数，模，1// int + double --> double + double --> doubledouble result3 = x + 2.5;System.out.println(result3); // 12.5}}/*运算符：进⾏特定操作的符号。
例如：+表达式：⽤运算符连起来的式⼦叫做表达式。
例如：20 + 5。
⼜例如：a + b四则运算：加：+减：-乘：*除：/取模（取余数）：%⾸先计算得到表达式的结果，然后再打印输出这个结果。
复习⼀下⼩学⼀年级的除法公式：被除数 / 除数 = 商 ... 余数对于⼀个整数的表达式来说，除法⽤的是整除，整数除以整数，结果仍然是整数。
只看商，不看余数。
只有对于整数的除法来说，取模运算符才有余数的意义。
注意事项：1. ⼀旦运算当中有不同类型的数据，那么结果将会是数据类型范围⼤的那种。
*/。
javabean实现四则运算
computer.jsp页面<%@ page language="java" import="java.util.*" pageEncoding="gbk"%><%@ page import="tom.jiafei.*"%><%String path = request.getContextPath();String basePath = request.getScheme() + "://"+ request.getServerName() + ":" + request.getServerPort()+ path + "/";%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'computer.jsp' starting page</title><meta http-equiv="pragma" content="no-cache"><meta http-equiv="cache-control" content="no-cache"><meta http-equiv="expires" content="0"><meta http-equiv="keywords" content="keyword1,keyword2,keyword3"><meta http-equiv="description" content="This is my page"><!--<link rel="stylesheet" type="text/css" href="styles.css">--></head><jsp:useBean id="com" class="puterBean" scope="session"></jsp:useBean> <body bgcolor="yellow"><h2>四则运算</h2><jsp:setProperty name="com" property="*" /><form action="" method="post" name="form"><input type="text" name="number1"value=<jsp:getProperty name="com" property="numberOne"/> size=5> <select name="operator"><option value="+">+<option value="-">-<option value="*">*<option value="/">/</select><input type="text" name="number2"value=<jsp:getProperty name="com" property="numberTwo"/> size=5> =<jsp:getProperty name="com" property="result" /><P><input type="submit" name="sub" value="计算"></form></body></html>ComputerBean.java页面package tom.jiafei;public class ComputerBean {double numberOne, numberTwo, result;String operator = "";public void setNumberOne(double m) {numberOne = m;}public double getNumberOne() {return numberOne;}public void setNumberTwo(double n) {numberTwo = n;}public double getNumberTwo() {return numberTwo;}public void setOperator(String s) {operator = s;}public String getOperator() {return operator;}public double getResult() {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;}}。
JAVA-WEB-简单的四则运算
JAVA-WEB-简单的四则运算⾸先附上选择题⽬数量和每⾏题数的JSP代码<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %><meta http-equiv="Content-Type" content="text/html;charset=ytf-8"><title>四则运算</title></head><%Object message=request.getAttribute("message");if(!(message==null||message.equals(""))){%><script type="text/javascript">alert('<%=message%>')</script><%}%><body style="background-color:pink" align="center"><form action="SizeServlet?method=submit" method="post"><br><br><br><br><br><br><br><br><p style="padding-left:200px;">请输⼊您要出多少道题:<input type="text" style="width:50px" name="sum"></p><p style="padding-left:200px;">请输⼊⼀⾏⼏到题:<input type="text" style="width:50px" name="n"></p><p style="padding-left:200px;"><input type="submit" value="提交"></p></form></body></html>现在是接收的Servlet层package math;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;/*** Servlet implementation class SizeServlet*/@WebServlet("/SizeServlet")public class SizeServlet extends HttpServlet {private static final long serialVersionUID = 1L;/*** @see HttpServlet#HttpServlet()*/public SizeServlet() {super();// TODO Auto-generated constructor stub}protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException{arg0.setCharacterEncoding("utf-8");arg1.setCharacterEncoding("utf-8");String function=arg0.getParameter("method");if(function.equals("submit")){String str;int sum,n;str=arg0.getParameter("sum");if(str==""||str==null){arg0.setAttribute("message", "提交失败,题⽬数不能为空");arg0.getRequestDispatcher("NewFile1.jsp").forward(arg0, arg1);return;}sum=Integer.valueOf(str).intValue();str=arg0.getParameter("n");if(str==""||str==null){arg0.setAttribute("message", "提交失败,每⾏个数不能为空");arg0.getRequestDispatcher("NewFile1.jsp").forward(arg0, arg1);return;}n=Integer.valueOf(str).intValue();SizeService.setSum(sum);SizeService.setN(n);if(sum<=1000&&n<=8&&n>0){arg0.setAttribute("message", "提交成功");arg0.getRequestDispatcher("NewFile.jsp").forward(arg0, arg1);return;}else{arg0.setAttribute("message", "提交失败");arg0.getRequestDispatcher("NewFile1.jsp").forward(arg0, arg1);return;}}}/*** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)*/protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {// TODO Auto-generated method stubresponse.getWriter().append("Served at: ").append(request.getContextPath());}/*** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)*/protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {// TODO Auto-generated method stubdoGet(request, response);}}然后是出题的代码<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><%@ page language="java" import="math.StringHandle"%><%@ page language="java" import="math.EntityToString"%><%@ page language="java" import="math.MathGenerate"%><%@ page language="java" import="math.SizeService"%><title>四则运算</title></head><body style="background-color:pink" align="center"><form action="NewFile2.jsp"><table align="center"><%MathGenerate mg=new MathGenerate();int m,n;m=SizeService.getSum();n=SizeService.getN();mg.generate(m, 1);for(int i=0;i<mg.getAnwser().size();){%><!-- ⼀⾏有⼏个 --><tr><%for(int j=0;j<n&&i<m;j++,i++){%><td ><%=mg.getQuestion().get(i) %></td><td>=</td><td><input type="hidden" name="question" value=<%=mg.getQuestion().get(i) %>></td><td><input type="text" style="width:50px" name="answer" ></td><td><input type="hidden" name="daan" value=<%=mg.getAnwser().get(i) %>></td><%} %></tr><%}%></table><p align="center"><input type="submit" value="提交"></p></form></body></html>其中出题代码中的MathGenerate（）是⾃⼰定义的⼀个出题的类，专门⽤来出题，这⾥可以改成⾃⼰写的任何其他的出题类然后就是判断做题是否正确的代码<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><%@ page language="java" import="math.SizeService"%><title>四则运算</title></head><body style="background-color:pink" align="center"><table align="center"><%String answer[]=request.getParameterValues("answer");String daan[]=request.getParameterValues("daan");String question[]=request.getParameterValues("question");int m,n;m=SizeService.getSum();n=SizeService.getN();for(int i=0;i<m;i++){if(answer[i].equals("")){%><tr><td>您没有做第<%=i+1 %>题:</td><td><%=question[i] %></td><td>=</td><td> </td><td>这道题的正确答案是<%=daan[i] %></td></tr><%}else if(daan[i].equals(answer[i])){%><tr><td>您做的第<%=i+1 %>题:</td><td><%=question[i] %></td><td>=</td><td><%=answer[i] %></td><td>恭喜您做对了这道题</td></tr><%}else{%><tr><td>您做的第<%=i+1 %>题:</td><td><%=question[i] %></td><td>=</td><td><%=answer[i] %></td><td>很遗憾您做错了这道题，正确答案是<%=daan[i] %></td></tr><%} %><%}%></table><a href="NewFile1.jsp"><button style="border:0px solid;background:lightblue;margin-left:50%;">重新做题</button></a> <br><br><a href="NewFile3.jsp"><button style="border:0px solid;background:red;margin-left:50%;">结束答题</button></a></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 style="background-image:url(44444.jpg);" align="center"><br><br><br><br><br><br><br><br><br><br><h1 style="color:red;font-size:500%" align="center">结束答题！</h1></body></html>其中插了⼀张图⽚可根据⾃⼰需要删除接下来是运⾏过程图⽚提交之后进⼊答题界⾯：点击提交进⼊判断正误界⾯（我没做这个题所以是这个样⼦）在判断完正误之后可以选择继续答题或者结束答题结束答题时这个样⼦的这个四则运算主要的就是在JSP⽂件中值进⾏传递和页⾯的跳转其他的问题都时⼀些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）最近我和我的⼩伙伴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> <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> <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 %> <%if((null==child_result)||("".equals(child_result))){nullerror++;%> 正确答案是<%=result[i]%><br><br><%}else{double child_result2=Double.valueOf(child_result);if(child_result2==result[i]){correct++;%>√<br><br><%}else{error++;%>× 正确答案是<%=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> <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版本）采⽤正则表达式//加减乘除负数、括号这⼏种//具体看代码以及注释 (测试没发现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初学者，在学习了基本数据类型之后，⼤哥给我布置了作业，内容如下： 计算题:假如今天逛超市花了99.99 请⽤加减乘除，进⾏计算得到99.99这个结果。
要求：1，4个⽅法； 2，数值随意编写； 3，数值要⽤到int、long、float、double四种类型； 4，都是返回值，实例化后打印。
⼀开始，我建了4个类，按照加减乘除的拼⾳分别命名为jia、jian、cheng、chu，代码如下所⽰。
1public class jia { //加法2int a = 10;3long b = 35;4float c = 36.95f;5double d = 18.04;6 public void jiafa() {7 double jia =a + b + c + d;8 System.out.println("加法运算结果是：" + jia);9 }10 }1public class jian { //减法2long a = 300;3int b = 18;4float c = 128.7f;5double d = 53.31;6public void jianfa() {7float jian = (float)(a - b - c - (double)d);8 System.out.println("减法运算结果是：" + jian);9 }10 }1 public class cheng { //乘法2 int a = 1;3 long b = 1000000;4 float c = 0.000001f;5 double d = 99.99;6 public void chengfa() {7 double cheng = a * b * c * d;8 System.out.println("乘法运算结果是：" + cheng);9 }10 }1public class chu { //除法2int a = 1000;3long b = 1000000;4float c = 0.001f;5double d = 99.99;6public void chufa() {7 float chu = (float)((double)d/(a/b/c));8 System.out.println("除法运算结果是：" + chu);9 }10 }然后，新建⼀个类，命名为yunsuan，将上述四则运算实例化并输出结果，代码如下：1public class yunsuan {2public static void main(String[] args) {3 jia jiafa = new jia(); //实例化加法4 jian jianfa = new jian(); //实例化减法5 cheng chengfa = new cheng(); //实例化乘法6 chu chufa = new chu(); //实例化除法78 jiafa.jiafa(); //调⽤加法⽅法9 jianfa.jianfa();10 chengfa.chengfa();11 chufa.chufa();12 }13 }运⾏结果如下图： 除了乘法之外，其他的运算都没有得到我想要的99.99这个结果，这是为什么呢？ 经过讲解和查阅资料之后，原来浮点数是不适合精确计算的，原因是计算机⾥⾯数的计算都是⼆进制计算的，我们其实输⼊的⼗进制数，有些⼗进制数转换成⼆进制是可以精确转换，⽽有些转换则不是精确转换，得到的是⼀个最靠近它的数，所以这⾥⾯就存在⼀个误差。
四则运算实现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 语言中。
本文将围绕Java中的四则运算展开，介绍其基本概念、用法和注意事项。
一、加法运算加法是最基本的运算之一，用于计算两个数的和。
在Java中，使用加号（+）进行加法运算。
例如，计算两个整数的和可以使用以下代码：int a = 5;int b = 3;int sum = a + b;System.out.println("两个整数的和为：" + sum);二、减法运算减法也是常用的运算方式，用于计算两个数的差。
在Java中，使用减号（-）进行减法运算。
例如，计算两个整数的差可以使用以下代码：int a = 5;int b = 3;int difference = a - b;System.out.println("两个整数的差为：" + difference);三、乘法运算乘法是常用的运算方式，用于计算两个数的积。
在Java中，使用星号（*）进行乘法运算。
例如，计算两个整数的积可以使用以下代码：int a = 5;int b = 3;int product = a * b;System.out.println("两个整数的积为：" + product);四、除法运算除法是常用的运算方式，用于计算两个数的商。
在Java中，使用斜杠（/）进行除法运算。
例如，计算两个整数的商可以使用以下代码：int a = 5;int b = 3;int quotient = a / b;System.out.println("两个整数的商为：" + quotient);需要注意的是，如果除数为0时，会出现除数为0的异常，需要进行异常处理。
五、运算顺序在四则运算中，有一定的运算顺序。
在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中的元素并输出，结果即为中缀表达式对应的前缀表达式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
package arrays.myArray;import java.util.Scanner;public class SortObject {private static int intercePosition = 0; // 记录单个运算数据的长度private static int[] intercePositionIndex = null; // 记录“（”的下标private static int[] intercePositionEnd = null; // 记录“）”的下标public static void main(String[] args) {Scanner input = new Scanner(System.in);do {System.out.println("请输入你要计算的字符串(注意：只能输入数字和加，减，乘除符号;输入完毕后,请直接回车):");String numberString = input.next().trim();// 判断输入的运算字符串是否符合规定if (ispassString(numberString) == false) {System.out.println("您输入的计算字符串有误,请正确输入!");} else {// 计算结果返回System.out.println(interceResult(numberString));}} while (true);}// 判断是否有带括号的运算字符串存在private static String interceResult(String str) {String result = str;char[] numberString = str.toCharArray(); // 1+2+(1*2+1-1*2+5)+2+(1+5+9+10-11)+1*5/2+3 // 1+8-9+(1*8/2-5+(1+2+8))+4/5*8/3*2int IndexStart = 0; // 记录“（”的实际数量int EndStart = 0; // 记录“）”的实际数量for (int i = 0; i < numberString.length; i++) {if ('(' == numberString[i]) {// 记录最后一个正括号的位置IndexStart = i;}if (')' == numberString[i]) {// 记录反括号的最初始下标的位置EndStart = i;// 截取最里面一个括号里的运算字符串result = result.substring(IndexStart + 1, EndStart);// 截取括号的运算字符串进行运算,生成新的运算字符串result = str.substring(0, IndexStart)+ interceptOperation(result, '*', '/')+ str.substring(EndStart + 1, str.length());// 回调执行，其它小括号的运算字符串return interceResult(result);}if (i == numberString.length - 1)if (EndStart == 0)break;}// 不存在括号了，再进行混合运算result = interceptOperation(str, '*', '/');return result;}// 不带括号的四则运算private static String interceptOperation(String operationNumber, char a, char b) {String mess = operationNumber;char[] stringOperation = mess.toCharArray();// 循环遍历运算字符串，并做相应的运算for (int i = 0; i < stringOperation.length; i++) {// 判断运算符所在的索引if (stringOperation[i] == a || stringOperation[i] == b) {if (i != 0) {// 运算符前的第一个数double num1 = interceptNumIndex(mess.substring(0, i));// 记录第一个数据的长度int frontPosition = intercePosition;// 运算符前的第二个数double num2 = interceptNumEnd(mess.substring(i + 1,stringOperation.length));// 记录第二个数据的长度int backPosition = intercePosition;// 算完乘除，将结果替换到原来运算的位置，得到新的运算字符串String IndexMess = mess.substring(0, i - frontPosition + 1);String IndexResult = "";// 判断是否运算到最后的结果了if (IndexMess.indexOf('+') == -1&& IndexMess.indexOf('*') == -1&& IndexMess.indexOf('/') == -1&& stIndexOf('-') == -1)IndexMess = "";if (IndexMess != "")IndexResult = stIndexOf('-') == IndexMess.length() - 1 ? IndexMess.substring(0, i- frontPosition) : IndexMess;// 组装新的运算字符串mess = IndexResult// mess.substring(0,i-frontPosition+1)+ reslutString("" + stringOperation[i], num1, num2)+ mess.substring(i + backPosition + 1);// 0.111/1212/2/2/2/2/2/2/2if (stIndexOf('-') == 0 && mess.indexOf('+') == -1&& mess.indexOf('*') == -1&& mess.indexOf('/') == -1) {break;}// 回调，继续运算return interceptOperation(mess, a, b);// 1+7-5+89/3+4-6*8/2+4-6 } elsecontinue;}if (i == stringOperation.length - 1) {// 递归出口，判断是否还有运算字符串在if (mess.indexOf('+') != -1 || mess.indexOf('-') != -1)return interceptOperation(mess, '+', '-');break;}}return mess;}// 截取第二个数private static double interceptNumEnd(String str) {double a = 0;int InrerceIndex = 0;char[] stringOperation = str.toCharArray();boolean ispas = false; // 记录是否为负数for (int i = 0; i < stringOperation.length; i++) {switch (stringOperation[i]) {case '*':case '/':case '+':case '-':InrerceIndex = i;if (i != 0) // 判断该数是否为负数ispas = true;break;default:break;}if (ispas)break;}// 判断此数据是否在运算字符串的最后一位if (InrerceIndex == 0) {a = Double.parseDouble(str);intercePosition = str.length();if (ispas)intercePosition++;} else {a = Double.parseDouble(str.substring(0, InrerceIndex)); // 记录数据的真实长度intercePosition = str.substring(0, InrerceIndex).length(); }return a;}// 截取第一个数private static double interceptNumIndex(String str) { double a = 0; // 记录数据int InrerceIndex = 0; // 记录运算符的位置boolean temp = false; // 记录数据前运算符的状态char[] stringOperation = str.toCharArray();for (int i = stringOperation.length - 1; i >= 0; i--) { switch (stringOperation[i]) {case '*':case '/':case '+':case '-':InrerceIndex = i;temp = true;break;default:break;}if (temp)break;}// 判断此数据是否在运算字符串的第一位if (InrerceIndex == 0) {a = Double.parseDouble(str);intercePosition = str.length();// if(temp)// intercePosition++;} else {a = Double.parseDouble(str.substring(InrerceIndex, str.length())); // 记录数据的真实长度intercePosition = str.substring(InrerceIndex, str.length()).length();}return a;}// 计算结果private static double reslutString(String operation, double num1, double num2) {double sumResult = 0;if (operation.equals("*"))sumResult = num1 * num2;if (operation.equals("-"))sumResult = num1 - num2;if (operation.equals("/"))sumResult = num1 / num2;if (operation.equals("+"))sumResult = num1 + num2;return sumResult;}// 判断是否正确输入运算方式private static boolean ispassString(String messString) {boolean ispass = false;boolean operationIspass = true; // 记录被除数的状态int ai = 0; // 记录是否有运算符号的存在char[] IsString = messString.toCharArray();int num1 = 0;int num2 = 0;for (int i = 0; i < IsString.length; i++) {// 记录有几对小括号的存在if ('(' == IsString[i])num1++;if (')' == IsString[i])num2++;// 判断除数是否为零if ('/' == IsString[i] && IsString[i + 1] == '0')operationIspass = false;// 判断是否输入了运算符合if (IsString[i] == '+' || IsString[i] == '-' || IsString[i] == '*'|| IsString[i] == '/')ai++;if (i == IsString.length - 1)if (ai == 0)num2++;}if (operationIspass)if (num1 == num2)ispass = true;return ispass;}}。