四则运算(Java)--温铭淇，付夏阳
GitHub项目地址：
https://github.com/fxyJAVA/Calculation
四则运算项目要求：
程序处理用户需求的模式为：
Myapp.exe -n num -r size
Myapp.exe -e
-
基本功能列表：
（1）【实现】使用 -n 参数控制生成题目的个数。
（2）【实现】使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围。
（3）【实现】生成的题目中计算过程不能产生负数，也就是说算术表达式中如果存在形如e1 − e2的子表达式，那么e1 ≥ e2。
（4）【实现】生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。
（5）【实现】每道题目中出现的运算符个数不超过3个。
（6）【实现】程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。生成的题目存入执行程序的当前目录下的Exercises.txt文件
（7）【实现】在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件。
（8）【实现】程序应能支持一万道题目的生成。
（9）【实现】程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计。
PSP表:
| PSP2.1 | Personal Software Process Stages | 预估耗时（分钟） | 实际耗时（分钟） |
|---|---|---|---|
| Planning | 计划 | 40 | 60 |
| · Estimate | · 估计这个任务需要多少时间 | 40 | 60 |
| Development | 开发 | 1280 | 1780 |
| · Analysis | · 需求分析 (包括学习新技术) | 100 | 200 |
| · Design Spec | · 生成设计文档 | 50 | 100 |
| · Design Review | · 设计复审 (和同事审核设计文档) | 40 | 100 |
| · Coding Standard | · 代码规范 (为目前的开发制定合适的规范) | 10 | 20 |
| · Design | · 具体设计 | 50 | 150 |
| · Coding | · 具体编码 | 800 | 900 |
| · Code Review | · 代码复审 | 30 | 50 |
| · Test | · 测试（自我测试，修改代码，提交修改） | 200 | 250 |
| Reporting | 报告 | 120 | 150 |
| · Test Report | · 测试报告 | 90 | 120 |
| · Size Measurement | · 计算工作量 | 5 | 10 |
| · Postmortem & Process Improvement Plan | · 事后总结, 并提出过程改进计划 | 15 | 20 |
| 合计 | 1430 | 2090 |
解题思路：
初看题时，眼前的一道难关就是分数的问题，真分数，假分数，分数计算等。刚开始我和搭档温，对这一步的实现，首先我和温是分开实现的，我是单纯用字符串，字符串切分进行结果的计算，十分繁杂，且不利于后续的功能实现：加括号，顺序随机化等。后来发现温将数字写成一个类，十分惊喜于这个巧妙的设计，java本身就是面向对象的语言，我却忽略了这个重要的点，纯用面向过程思维来考虑了。取长补短走过了这一道难关，将数字定义为一个类极大便利了我们后续功能的实现。后续遇到的判重问题，我想的是用HashMap的特性，一个key对应一个value，key是唯一key。如果我将算式的结果作为key，那么value就是算式本身。我们可知，结果不同的算式一定不相同，因此仅这一步我们就过滤掉了重复的问题，但因为此方法有一定的误判可能，于是在后续补上了判重的方法，来降低误判的可能。
设计实现过程
以main()为中心，通过cmd传入参数到main(String[] args)获取操作和文件路径，根据参数来判断进行何种操作 。生成算式则调用Utils的静态方法生成，要写文件和检查则调用FileUtils的静态方法生成，而Fraction类则贯穿其中，是功能实现的核心。
效能分析
因为测试的时候未发现生成算式和写文件效率并未出很低的情况，在生成算式和写文件时，以10000条数据为例，测试仅用了383毫秒，最坏情况也不超过2秒，暂无思路做到进一步的方法优化。
代码说明
Main.java，通过args获取要执行的操作：
根据程序处理用户需求的模式
1）Myapp.exe -n num -r size
生成题目，其中num为题数，size为生成数的大小
调用FileUtils.creatFile(Utils.createSuanShi(num,size))
2）Myapp.exe -e exercisefile.txt -a answerfile.txt
判断答案的正确率，其中exercisefile.txt为生成练习题的路径 、answerfile.txt为答案的路径
调用FileUtils.check(exercisePath,answerPath);
import java.io.IOException;
public class main {
public static void main(String[] args) {
int num = 0;
int size = 0;
String exercisePath = null;
String answerPath = null;
if(args.length != 0){
for(int i = 0; i < args.length; i++){
//"-n指令"
if(args[i].equals("-n")) {
try {
num = Integer.parseInt(args[i+1]);
}catch (NumberFormatException e) {
System.out.println("参数有误!");
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("参数有误!");
}
}
//"-r指令"
if(args[i].equals("-r")) {
try {
size = Integer.parseInt(args[i+1]);
}catch (NumberFormatException e) {
System.out.println("参数有误!");
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("参数有误!");
}
}
if(args[i].equals("-e")){
try{
exercisePath = args[i+1];
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("参数有误!");
}
}
if(args[i].equals("-a")){
try{
answerPath = args[i+1];
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("参数有误!");
}
}
}
if(num != 0 && size != 0){
FileUtils.creatFile(Utils.createSuanShi(num,size));
}
if(exercisePath != null && answerPath != null){
try {
FileUtils.check(exercisePath,answerPath);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
以下是相应的util类：
首先是创造算式集合方法 createSuanShi，在这里传入决定生成的算式数目，算式取值范围；
createFun则是生成算式方法，根据传过来的要求数目，while循环生成算式，放入HashMap。
这里算式结果作为key，算式本身作为value。这样做的目的是判重，当我生成的结果在hashmap中存在value，我就判定该算式不成立，算入重复，但这样做会有错误过滤。因而在该方法中又重新定义了判重的方法，思路为：先判断结果是否相同->再判断运算符数目是否相同且相等->最后判断运算数是否相等，相等则我认为是重复算式，不计入map中。
createFra为生成算数，同时判断是否要生成分数
whoBig为判断算数a,b的大小，以防出现结果为负数
最后简要说说加入（）的时机，因为传参是数组的缘故，所以根据计算符号的先后位置来决定是否加入括号，例如：我传入了运算符顺序是：+，—，* 在运算到乘法的时候，因为我已经计算了+，-的结果，所以我在这里需要判断前两位操作符是什么，若为+，—，则代表着我需要加入乘法前，给已生成的算式加上（）。其他情况皆以此类推。
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
public class Utils {
public static HashMap<String, String> createSuanShi(int createNum, int size) {
if (size == 0) {
size = 100;
}
HashMap<String, String> weWant = new LinkedHashMap<>();
while (weWant.size() < createNum) {
int opNum = (int) (Math.random() * 3) + 1;
String[] op = new String[opNum];
for (int j = 0; j < opNum; j++) {
int temp = (int) (Math.random() * 4);
switch (temp) {
case 0: {
op[j] = "+";
break;
}
case 1: {
op[j] = "-";
break;
}
case 2: {
op[j] = "*";
break;
}
case 3: {
op[j] = "÷";
break;
}
}
}
String[] result = createFun(op, size).split("=");
//判重
if ((weWant.get(result[1]))!=null) {
String whoAreYou = weWant.get(result[1]);
int calChar =0;
for (int a=0;a<op.length;a++) {
if (whoAreYou.contains(op[a]))
calChar++;
}
if(calChar == op.length) {
StringBuilder sb = new StringBuilder(whoAreYou);
while(sb.toString().contains("(")) {
sb.deleteCharAt(sb.lastIndexOf("("));
}
while(sb.toString().contains(")")) {
sb.deleteCharAt(sb.lastIndexOf(")"));
}
StringBuilder sb2 = new StringBuilder(result[0]);
while(sb2.toString().contains("(")) {
sb2.deleteCharAt(sb2.lastIndexOf("("));
}
while(sb2.toString().contains(")")) {
sb2.deleteCharAt(sb2.lastIndexOf(")"));
}
String[] numArr1 = sb.toString().split("[\\+\\-\\*\\÷]");
String numArr2 = Arrays.toString(sb2.toString().split("[\\+\\-\\*\\÷]"));
int xxx=0;
for (int b = 0;b<numArr1.length;b++) {
if(numArr2.contains(numArr1[b])) {
xxx++;
}
}
if(xxx==numArr1.length) {
continue;
}
}
}
weWant.put(result[1], result[0]);
}
return weWant;
}
public static String createFun(String[] op, int size) {
StringBuffer suanShi = new StringBuffer();
//确定符号数
int length = op.length;
//初始化结果为0
Fraction result = new Fraction(0, 1);
for (String c : op) {
switch (c) {
case "+": {
if (suanShi.length() > 0 && suanShi != null) {
Fraction c1 = createFra(size);
result = result.add(c1);
if ((suanShi.toString().contains("*") || suanShi.toString().contains("÷")) && (int) (Math.random() * 2) == 0 && length == 2) {
suanShi.insert(0, c1.getFraction() + "+");
} else if (suanShi.toString().contains("*") && suanShi.toString().contains("÷") && (int) Math.random() * 3 == 0) {
suanShi.insert(0, c1.getFraction() + "+");
} else {
if (length == 3 && suanShi.toString().contains("÷") && op[0] == "-") {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
suanShi.append("+" + c1.getFraction());
}
} else {
Fraction a = createFra(size);
Fraction b = createFra(size);
result = a.add(b);
suanShi.append(a.getFraction() + "+" + b.getFraction());
}
break;
}
case "-": {
if (suanShi.length() > 0 && suanShi != null) {
Fraction c1 = createFra(size);
boolean flag = whoBig(result, c1);
if (flag) {
result = c1.sub(result);
} else {
result = result.sub(c1);
}
if ((flag && suanShi.toString().contains("*") || suanShi.toString().contains("÷")) && (int) (Math.random() * 3) == 0 && (length == 2 || length == 3)) {
if (length == 3 && (suanShi.toString().contains("*") || suanShi.toString().contains("÷")) && op[1] == "+") {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
suanShi.insert(0, c1.getFraction() + "-");
} else if (flag && suanShi.toString().contains("*") && suanShi.toString().contains("÷") && (int) (Math.random() * 3) == 0) {
if (length == 3 && (suanShi.toString().contains("*") || suanShi.toString().contains("÷")) && op[1].equals("+")) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
suanShi.insert(0, c1.getFraction() + "-");
} else {
if (flag) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
suanShi.insert(0, c1.getFraction() + "-");
} else {
suanShi.append("-" + c1.getFraction());
}
}
if (length == 3 && op[1].equals("-") && (op[2].equals("*") || op[2].equals("÷"))) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
} else {
Fraction a = createFra(size);
Fraction b = createFra(size);
if (whoBig(a, b)) {
result = b.sub(a);
suanShi.append(b.getFraction() + "-" + a.getFraction());
} else {
result = a.sub(b);
suanShi.append(a.getFraction() + "-" + b.getFraction());
}
}
break;
}
case "*": {
if (suanShi.length() > 0 && suanShi != null) {
Fraction c1 = createFra(size);
result = result.mul(c1);
if (length == 3 && (op[0].equals("+") || op[0].equals("-")) && (op[1].equals("+") || op[1].equals("-")) && !suanShi.toString().contains("(")) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
} else {
if ((length == 2 || length == 3) && ((suanShi.toString().contains("+") || suanShi.toString().contains("-"))) && !suanShi.toString().contains("(")) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
if (length == 3 && (suanShi.toString().contains("÷") && (suanShi.toString().contains("+") || suanShi.toString().contains("-"))) && !suanShi.toString().contains("((") && op[0] != "*") {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
}
suanShi.append("*" + c1.getFraction());
} else {
Fraction a = createFra(size);
Fraction b = createFra(size);
result = a.mul(b);
suanShi.append(a.getFraction() + "*" + b.getFraction());
}
break;
}
case "÷": {
if (suanShi.length() > 0 && suanShi != null) {
Fraction c1 = createFra(size);
while (c1.getNumerator() == 0) {
c1 = createFra(size);
}
result = result.div(c1);
if ((length == 3 && (op[0].equals("+") || op[0].equals("-")) && (op[1].equals("+") || op[1].equals("-")) && !suanShi.toString().contains("("))) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
if ((length == 2 || length == 3) && (suanShi.toString().contains("+") || suanShi.toString().contains("-")) && (suanShi.toString().contains("*") && suanShi.toString().contains("÷"))) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
if (length == 3 && (suanShi.toString().contains("*")) && ((suanShi.toString().contains("+") || suanShi.toString().contains("-"))) && !suanShi.toString().contains("((") && !op[0].equals("*")) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
if (length == 3 && (suanShi.toString().contains("+") || suanShi.toString().contains("-")) && (op[2].equals("-") || op[2].equals("+"))) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
if (length == 3 && op[1].equals("÷") && (op[0].equals("+") || op[0].equals("-"))) {
suanShi.insert(0, "(");
suanShi.insert(suanShi.length(), ")");
}
suanShi.append("÷" + c1.getFraction());
} else {
Fraction a = createFra(size);
Fraction b = createFra(size);
while (b.getNumerator() == 0) {
b = createFra(size);
}
result = a.div(b);
suanShi.append(a.getFraction() + "÷" + b.getFraction());
}
break;
}
}
}
return suanShi.append("=" + (result.getNumerator() == 0 ? 0 : result.getFraction())).toString();
}
private static boolean whoBig(Fraction l, Fraction r) {
boolean flag = false;
if (l.getNumerator() * r.getDenominator() < l.getDenominator() * r.getNumerator()) {
flag = true;
}
return flag;
}
private static Fraction createFra(int size) {
if ((int) (Math.random() * 3) == 0) {
return new Fraction((int) (Math.random() * size + 1), (int) (Math.random() * size) + 2);
} else {
return new Fraction((int) (Math.random() * size + 1), 1);
}
}
}
数字类，得意于将数字定义为一个类，且集合了加减乘除，约分等对分数的处理，使得后面的流程可以专注于业务需求上，计算方面只需丢给该类的方法即可完成运算。
public class Fraction {
private int numerator;//分子
private int denominator;//分母
public Fraction(int a,int b){
setNumeratorAndDenominator(a,b);
}
public void setNumeratorAndDenominator(int a, int b){ // 设置分子和分母
int c = 1;
if(a!=0) {
c = largestCommonDivisor(a, b);// 计算最大公约数
}
numerator = a / c;
denominator = b / c;
}
public int largestCommonDivisor(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;
}
public int getNumerator(){
return numerator;
}
public int getDenominator(){
return denominator;
}
public String getFraction(){ //获得分数的表达，根据分子分母的大小关系是否化为带分数
String str;
if(denominator == 1) { //分母为1，只看分子的大小
str = String.valueOf(this.numerator);
}else if(numerator == denominator){ //分子分母相等，输出1
str = "1";
}else if(numerator > denominator){ //分子大于分母，转化为带分数
int roundNumber = numerator / denominator;
int newNumerator = numerator - denominator * roundNumber;
str = roundNumber + "'" + newNumerator + "/" + this.denominator;
}else{ //否则按正常的分数输出
str = this.numerator + "/" + this.denominator;
}
return str;
}
public Fraction add(Fraction r){ // 加法运算，通分后再运算
int a = r.getNumerator();
int b = r.getDenominator();
int newNumerator = this.numerator * b + this.denominator * a;
int newDenominator = this.denominator * b;
Fraction result = new Fraction(newNumerator,newDenominator);
return result;
}
public Fraction sub(Fraction r){ // 减法运算
int a = r.getNumerator();
int b = r.getDenominator();
int newNumerator = numerator * b - denominator * a;
int newDenominator = denominator * b;
Fraction result = new Fraction(newNumerator,newDenominator);
return result;
}
public Fraction mul(Fraction r){ // 乘法运算
int a = r.getNumerator();
int b = r.getDenominator();
int newNumerator = this.numerator * a;
int newDenominator = this.denominator * b;
Fraction result = new Fraction(newNumerator,newDenominator);
return result;
}
public Fraction div(Fraction r){ // 除法运算
int a = r.getNumerator();
int b = r.getDenominator();
int newNumerator = numerator * b;
int newDenominator = denominator * a;
Fraction result = new Fraction(newNumerator,newDenominator);
return result;
}
}
FileUtils类主要用于生成文件，和读取文件
createFile为生成文件方法，前面通过utils方法获得算式集，迭代获取算式和结果值，通过字符流（PrintWriter）分别写入到两个文件：Exercises@日期.txt Answers@日期
check方法主要用于比对答案是否正确，通过获取传进来的question获取对应的答案文件读取答案与读取到的yourAnswer文件匹配，匹配结果写入到grade文件中，以及输出到控股台。
import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
public class FileUtils {
public static void creatFile(HashMap map) {
LocalDateTime time = LocalDateTime.now();
String timeFor = time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"));
File question = new File("D:\\Exercises@"+timeFor+".txt");
File answer = new File("D:\\Answers@"+timeFor +".txt");
try {
question.createNewFile();
answer.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
try (PrintWriter questionWrite = new PrintWriter(new FileWriter(question, true));
PrintWriter answerWrite = new PrintWriter(new FileWriter(answer, true));) {
int jiShu = 0;
for (Object entry : map.entrySet()) {
Map.Entry<String, String> temp = (Map.Entry<String, String>) entry;
String key = temp.getKey();
String value = temp.getValue();
questionWrite.write(jiShu+1+". "+value+"= ");
questionWrite.write("\r\n");
questionWrite.write("\r\n");
answerWrite.write(jiShu+1+". "+key);
answerWrite.write("\r\n");
answerWrite.write("\r\n");
jiShu++;
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void check(String question,String yourAnswer) throws IOException {
String answers = question.split("@")[1];
File answersOff = new File("D:\\Answers@"+answers);
File yourAnswers = new File(yourAnswer);
if(!yourAnswers.exists()) {
System.out.println("未找到文件，请重新确认文件路径");
System.exit(0);
}
if(!answersOff.exists()) {
System.out.println("答案文件不存在，请确认");
System.exit(0);
}
LocalDateTime time = LocalDateTime.now();
String timeFor = time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"));
File grade = new File("D:\\Grade@"+timeFor+".txt");
grade.createNewFile();
try(BufferedReader answersOffReader = new BufferedReader(new FileReader(answersOff));
BufferedReader yourAnswersReader = new BufferedReader(new FileReader(yourAnswers));
PrintWriter gradeWrite = new PrintWriter(new FileWriter(grade))) {
String temp ;
String ans ;
StringBuilder r = new StringBuilder();
r.append("(");
StringBuilder w = new StringBuilder();
w.append("(");
int right = 0;
int wrong = 0;
ans=answersOffReader.readLine();
while ((temp=yourAnswersReader.readLine())!=null ) {
if(temp.equals("\r\n") || temp.equals("")) {
continue;
}
while(ans==null || ans.equals("")) {
ans=answersOffReader.readLine();
}
String xuHao =ans.split("\\.")[0];
if(temp.split("\\.").length>1) {
ans =ans.split("\\.")[1].trim();
String tempAnswer = temp.split("\\.")[1].trim();
if(tempAnswer.equals(ans)) {
r.append(xuHao+",");
right++;
}else {
w.append(xuHao+",");
wrong++;
}
}else {
w.append(xuHao+",");
wrong++;
continue;
}
ans = answersOffReader.readLine();
}
if(r.toString().contains(",")) {
r.deleteCharAt(r.lastIndexOf(","));
}
if(w.toString().contains(",")) {
w.deleteCharAt(w.lastIndexOf(","));
}
r.insert(r.length(),")");
w.insert(w.length(),")");
gradeWrite.write("Correct:"+right+r.toString());
gradeWrite.write("\r\n");
gradeWrite.write("Wrong:"+wrong+w.toString());
System.out.println("Correct:"+right+r.toString());
System.out.println("Wrong:"+wrong+w.toString());
}
}
}
测试运行
答题者的答案需另起一个文档，格式参照正确答案
命令行：
题目：
答案：
判断答案：
生成文件：
覆盖率：
项目小结
通过这次项目实战，我们又复习了javaSE的一些知识，比如java的集合类HashMap，文件的输入输出流，面向对象等知识，还有些细节性的一些知识点，比如为什么用StringBuilder而不用STring和StringBuffer等。又因为是两人合作开发，在开发时就不能
一意孤行，要结合队友的思路，彼此交流，言语表达要使对方能理解你的思路，探讨不足和取长补短，这样才能进行下一步的深入研究，也才有了我们现在完成的项目。通过此次开发，我们都体会到了合作开发的优势，开始有了团队意识，写代码时，会留
意注释是否到位等，另外一项收获就是如何进行项目管理，版本控制，防止开发时出现版本冲突等问题，较好的进行版本迭代。
