java用户界面项目_结对项目（带图型用户界面）Java实现【柴政-陈起廷】
对分数及整数的计算
/***
* 相加操作
*/
ADD("+") {
@Override
public String calculate(String a, String b) {
boolean flagA = a.contains("/");
boolean flagB = b.contains("/");
//两个都是分数
if (flagA && flagB) {
int[] anInt = ResolveUtil.analysis(a);
int[] bnInt = ResolveUtil.analysis(b);
//以AB为分母
int denominator = anInt[1] * bnInt[1];
//相加后的分子
int molecule = anInt[0] * bnInt[1] + anInt[1] * bnInt[0];
return ResolveUtil.createFraction(molecule, denominator);
} else if (flagA) {
int[] anInt = ResolveUtil.analysis(a);
//直接更新分子便可
anInt[0] += Integer.parseInt(b) * anInt[1];
return ResolveUtil.createFraction(anInt[0], anInt[1]);
} else if (flagB) {
int[] bnInt = ResolveUtil.analysis(b);
//直接更新分子便可
bnInt[0] += Integer.parseInt(a) * bnInt[1];
return ResolveUtil.createFraction(bnInt[0], bnInt[1]);
} else {
return String.valueOf(Integer.parseInt(a) + Integer.parseInt(b));
}
}
},
/***
* 相乘操作
*/
MULTIPLY("×") {
@Override
public String calculate(String a, String b) {
boolean flagA = a.contains("/");
boolean flagB = b.contains("/");
if (flagA && flagB) {
int[] anInt = ResolveUtil.analysis(a);
int[] bnInt = ResolveUtil.analysis(b);
//以AB为分母
int denominator = anInt[1] * bnInt[1];
//分子相乘
int molecule = anInt[0] * bnInt[0];
return ResolveUtil.createFraction(molecule, denominator);
} else if (flagA) {
int[] anInt = ResolveUtil.analysis(a);
return ResolveUtil.createFraction(anInt[0] * Integer.parseInt(b), anInt[1]);
} else if (flagB) {
int[] bnInt = ResolveUtil.analysis(b);
return ResolveUtil.createFraction(bnInt[0] * Integer.parseInt(a), bnInt[1]);
} else {
return String.valueOf(Integer.parseInt(a) * Integer.parseInt(b));
}
}
},
/***
* 相除操作
*/
DIVIDE("÷") {
@Override
public String calculate(String a, String b) {
//除法，从另外一种角度来说，是乘法的倒转，所以，只需要把b分子分母倒过来用乘法就行了
boolean flag = b.contains("/");
//新的数b的字符串
String newB;
//判断b是否为分数
if (flag) {
int[] bnInt = ResolveUtil.analysis(b);
newB = ResolveUtil.createFraction(bnInt[1], bnInt[0]);
} else {
newB = 1 + "/" + b;
}
return Symbol.MULTIPLY.calculate(a, newB);
}
},
/***
* 相减操作
*/
SUB("-") {
@Override
public String calculate(String a, String b) {
//减是加的特例，把b弄成-就可以了
return Symbol.ADD.calculate(a, "-" + b);
}
},
中缀转后缀表达式
/***
* 中缀表达式转换成后缀表达式
* @param expression 表达式
* @return 数组
*/
private String[] middleToAfter(String expression) {
//用来转换的栈
Stack stack = new Stack<>();
//表达式每个字符前后都会生成一个空格
String[] strings = expression.split("\\s");
//返回的list
List stringList = new ArrayList<>(strings.length);
for (int index = 0; index < strings.length; index++) {
if ('0' <= strings[index].charAt(0) && strings[index].charAt(0) <= '9') {
//数字直接输出
stringList.add(strings[index]);
} else if (strings[index].equals(Symbol.BEGIN.getSymbol())) {
//开始括号压进栈
stack.push(strings[index]);
} else if (strings[index].equals(Symbol.END.getSymbol())) {
//把所有运算符都出栈
while (!stack.peek().equals(Symbol.BEGIN.getSymbol())) {
stringList.add(stack.pop());
}
//出栈开始括号
stack.pop();
} else if (strings[index].equals(Symbol.MULTIPLY.getSymbol())
|| strings[index].equals(Symbol.DIVIDE.getSymbol())) {
//判断上一级符号是什么
boolean flag = !stack.isEmpty() && (stack.peek().equals(Symbol.MULTIPLY.getSymbol())
|| stack.peek().equals(Symbol.DIVIDE.getSymbol()));
if (flag) {
stringList.add(stack.pop());
}
stack.push(strings[index]);
} else if (strings[index].equals(Symbol.SUB.getSymbol())
|| strings[index].equals(Symbol.ADD.getSymbol())) {
//此处应该为+，-号
boolean flag = !stack.isEmpty() && (stack.peek().equals(Symbol.ADD.getSymbol())
|| stack.peek().equals(Symbol.SUB.getSymbol()));
if (flag) {
stringList.add(stack.pop());
}
stack.push(strings[index]);
} else {
//有其他符号，直接跳出，可能是=号
break;
}
}
while (!stack.isEmpty()) {
stringList.add(stack.pop());
}
//返回数组
return stringList.toArray(new String[0]);
}
后缀计算
/***
* 计算表达式
* @param expression 表达式
* @param permit 允许存在负数的运算过程
* @return 结果
*/
public String calculate(String expression, boolean permit) {
if (expression == null) {
return null;
}
//先生成后缀表达式数组，然后手动控制数组进行操作
String[] afterExp = middleToAfter(expression);
Stack stack = new Stack<>();
try {
for (int index = 0; index < afterExp.length; index++) {
if (afterExp[index].matches("[0-9/']+")) {
stack.push(afterExp[index]);
} else {
String b = stack.pop();
String a = stack.pop();
String result = Symbol.value(afterExp[index]).calculate(a, b);
//计算过程中存在负数，重新生成表达式
if (result.startsWith("-") && !permit) {
return null;
}
stack.push(result);
}
}
} catch (NullPointerException e) {
e.printStackTrace();
} catch (Exception e) {
System.out.println("存在表达式不合法");
}
return stack.pop();
}
生成表达式
/***
* 生成表达式
* @return 生成表达式
*/
private String generateExpression() {
//随机运算符大小
int operatorSize = (int) (Math.random() * MAX_OPERATOR_SIZE) + 1;
int numberSize = operatorSize + 1;
//判断是否需要生成括号,1/4的概率
boolean flag = (int) (Math.random() * MAX_OPERATOR_SIZE) == 0;
//标记(产生的位置)
int mark = -1;
if (flag) {
//随机插入括号的位置
mark = (int) (Math.random() * operatorSize);
}
StringBuilder expression = new StringBuilder();
//遍历产生数字和符号，你一下我一下
for (int i = 0; i < numberSize; i++) {
if (mark == i) {
myAppend(expression, "(");
}
//生成数字
myAppend(expression, (int) (Math.random() * 2) == 0 ? generateFraction() : generateInt());
//判断是否加入结束符号，判断是否结尾
if (mark >= 0 && mark < i) {
//已经到了表达式结尾, 此时必须结束
if (i == operatorSize) {
myAppend(expression, ")");
break;
}
//判断是否需要结束
flag = (int) (Math.random() * 2) == 0;
if (flag) {
myAppend(expression, ")");
mark = -1;
}
}
if (i < operatorSize) {
//然后生成一个操作符
myAppend(expression, generateOperator());
}
}
//最后补充等号
expression.append("=");
return expression.toString();
}
去重校验
/***
* 检查表达式是否已经存在或者重复
* @param expression 表达式
* @param result 结果
* @return 是否重复
*/
private boolean checkExpressionExistAndResultIllegal(String expression, String result) {
if (Objects.isNull(result)) {
return true;
}
//当前没有表达式
if (nowExpressionSize == 0) {
return false;
}
//API的一些操作也是循环，效率低下，手动循环
for (int i = 0, j = nowExpressionSize - 1; i <= j; i++, j--) {
if (expressionList.get(i).equals(expression) || expressionList.get(j).equals(expression)) {
return true;
}
//查看是否答案有相同的
if (answerList.get(i).equals(result)) {
return checkCharEquals(expressionList.get(i), expression);
} else if (answerList.get(j).equals(result)) {
return checkCharEquals(expressionList.get(j), expression);
}
}
return false;
}
/***
*
* @param oldExpression 存在的表达式
* @param newExpression 还没存进去的表达式
* @return 相同，不相同
*/
private boolean checkCharEquals(String oldExpression, String newExpression) {
String[] oldExpressionArrays = oldExpression.split("\\s+");
String[] newExpressionArrays = newExpression.split("\\s+");
int oldExpressionNumber = 0;
int equalsNumber = 0;
//是否为数字
boolean flag;
//开始遍历
for (String oldString : oldExpressionArrays) {
flag = oldExpression.matches("[0-9'/]+");
if (flag) {
oldExpressionNumber++;
}
//比对
for (String newString : newExpressionArrays) {
if (oldString.equals(newString)) {
equalsNumber++;
}
}
}
答案校对
//保存正确/错误题号的队列
private List correctList = new ArrayList<>();
private List wrongList = new ArrayList<>();
/**
* 校验待检测文件状态
* @param exersicesFile
* @param myAnswer
* @Author Naren
*/
public void checkFile(String exersicesFile,String myAnswer) {
//存储表达式的文件
File expFile = new File(exersicesFile);//Exercise002.txt
//待校验答案的文件
File myAnsFile = new File(myAnswer);//myAnswers001.txt
//待校验答案文件不存在
if(!myAnsFile.exists()){
//System.out.println("未找到待检验答案文件。");
new Tips().displayTips("noExpTip.png");
return;
}
//如果表达式文件不存在
if(!expFile.exists()) {
//System.out.println("未找到指定题目文件。");
new Tips().displayTips("noAnsTip.png");
return;
}
//如果全部文件名都正确，检测待校对题目文件是否存在于系统生成历史中
String id = exersicesFile.substring(9,12);
String sysAnsFile = "Answers" + id + ".txt"; //Myapp.exe -e Exercises001.txt -a myAnswers001.txt
File ansFile = new File(sysAnsFile);//Answers002.txt(不存在)
//若系统中不存在与题目文件相符合的答案文件
if(!ansFile.exists()){
try {
FileReader fr = new FileReader(expFile);
BufferedReader br = new BufferedReader(fr);
String content = null;
ArrayList questionList = new ArrayList<>();
while((content = br.readLine()) != null){//(?m)^.*$
content = content.split("\\.")[1];
questionList.add(content);
}
//调用起廷方法获得答案队列
Expression ex = new Expression(new Calculate());
List answerList = ex.getCorrectAnswerList(questionList);
//比对
checkAnswer(myAnsFile,answerList);
} catch (Exception e) {
System.out.println("Class:AnswerChecking,Method:checkFile(String,String) is wrong!");
}
}else{
//调用本类检验方法比对答案文件
checkAnswer(myAnsFile,ansFile);
}
}
/**
* 将待校验答案文件与现场计算出的答案队列进行比对
* @param myAnswer
* @param answerList
* @author Naren
*/
private void checkAnswer(File myAnswer, List answerList){
try {
//待检测答案文件
FileReader fr1 = new FileReader(myAnswer);
BufferedReader br1 = new BufferedReader(fr1);
LinkedHashMap map1 = new LinkedHashMap<>();
String content = "";
while((content = br1.readLine()) != null){
content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");
//map1待校验答案：key:序号，value:答案
map1.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);
}
//开始比对
for (int i = 0; i < answerList.size(); i++) {
if(map1.containsKey(i + 1)){
if(map1.get(i + 1).equals(answerList.get(i))) {
correctList.add(i + 1);//正确题号添加进队列
}
else{
wrongList.add(i + 1);//错误题号添加进队列
}
}else{
//漏写
wrongList.add(i + 1);
}
}
//将校验结果写入文件
//System.out.println("检验信息已写入Grade.txt文件。");
new Tips().displayTips("checkSuccess.png");
new DataStorage().storeCheckInfo(correctList,wrongList);
} catch (Exception e) {
System.out.println("Class:AnswerChecking,Method:checkAnswer(File,List) is wrong!");
}
}
/**
* 【重载】将待校验答案文件与本地答案文件进行比对
* @param myAnswer 待校验答案文件
* @param ansFile 正确答案文件
* @author Naren
*/
private void checkAnswer(File myAnswer, File ansFile) {
try {
FileReader fr1 = new FileReader(myAnswer);
FileReader fr2 = new FileReader(ansFile);
BufferedReader br1 = new BufferedReader(fr1);
BufferedReader br2 = new BufferedReader(fr2);
LinkedHashMap map1 = new LinkedHashMap<>();//待检测 key:序号，value:答案
LinkedHashMap map2 = new LinkedHashMap<>();//正 确 key:序号，value:答案
//分别按行读出答案
String content = "";
while((content = br1.readLine()) != null){
content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");
map1.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);
}
while((content = br2.readLine()) != null){
content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");
map2.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);
}
//开始比对
for (int i = 0; i < map2.size(); i++) {
if(map1.containsKey(i + 1)){
if(map1.get(i + 1).equals(map2.get(i + 1))) {
correctList.add(i + 1);//正确题号添加进队列
}
else{
wrongList.add(i + 1);//错误题号添加进队列
}
}else{
//漏写
wrongList.add(i + 1);
}
}
//将校验结果写入文件
//System.out.println("检验信息已写入Grade.txt文件。");
new Tips().displayTips("checkSuccess.png");
new DataStorage().storeCheckInfo(correctList,wrongList);
} catch (Exception e) {
System.out.println("Class:AnswerChecking,Method:checkAnswer(File,File) is wrong!");
}
}
总结
以上是生活随笔为你收集整理的java用户界面项目_结对项目（带图型用户界面）Java实现【柴政-陈起廷】的全部内容，希望文章能够帮你解决所遇到的问题。
- 上一篇： linux远程计算,如何使用Linux应
- 下一篇： java存钱_用Java编写银行存钱取钱