Miembros: Linyue Ling (3218005082), Luo Yi-Ming (3118005066)
- 1, dirección GitHub
- 2, la forma de PSP
- 3, análisis de rendimiento
- 4, diseño y proceso de implementación
- 5, Código Descripción
- 6, la prueba de funcionamiento
- 7, Resumen del proyecto
1, GitHub Dirección : https://github.com/HandsomeLuoYM/examination-system
2, la forma de PSP
| PSP2.1 | Etapas del Proceso de Software Personal | Estimado de consumo de tiempo (minutos) | Los que consumen mucho tiempo reales (minutos) |
|---|---|---|---|
| Planificación | plan | 60 | 45 |
| - Estimación | Estimar cuánto tiempo esta tarea requiere | 60 | 45 |
| Desarrollo | desarrollar | 1720 | 1700 |
| - Análisis | análisis de necesidades (incluyendo el aprendizaje de nuevas tecnologías) | 80 | 60 |
| - Diseño de especificaciones | Generar documentos de diseño | 30 | 20 |
| - Revisión de diseño | la revisión del diseño (y sus colegas revisaron los documentos de diseño) | 30 | 20 |
| - Estándar de Codificación | Especificaciones de códigos (desarrollo de normas apropiadas para el desarrollo actual) | 20 | 30 |
| - Diseño | diseño específico | 180 | 120 |
| - Codificación | codificación específica | 1200 | 1300 |
| - Revisión de código | Revisión del código | 60 | 45 |
| - Prueba | Prueba (autocomprobación, modificar el código, enviar modificaciones) | 120 | 105 |
| la presentación de informes | informe | 120 | 110 |
| - Informe de prueba | Informe de prueba | 60 | 40 |
| - Medición de Tamaño | cargas de trabajo informáticas | 30 | 20 |
| - Postmortem & Process Plan de Mejora | Más tarde se resume, y un plan de mejora de procesos | 30 | 50 |
| total | mil novecientos | 1855 |
3, análisis de rendimiento
Cuando me genera aleatoriamente 10.000 expresión: Se puede ver que el consumo de memoria de almacenamiento dinámico se estabilizó después de haber aumentado
Visto, en la alta eficiencia del grupo de Operadores seguimiento y la utilización CUP no es alto, pero el consumo de memoria por un corto tiempo para lograr un alto
Se pagan visto desde el siguiente informe, ya que un gran número de cálculos de suma, resta de la cadena, con el fin de reducir la carga de la máquina virtual, se utiliza la manipulación de cadenas StringBuilder a la mayoría
4, diseño y proceso de implementación
lenguaje de programación se determina en primer lugar, con el fin de reducir el costo de aprendizaje, utilizando Java familiarizados relacionados con el desarrollo, la demanda y la corrección de pruebas implica generado de forma aleatoria, se requiere una gran cantidad de cadena de funcionamiento, que se utiliza para llevar a cabo la correspondiente operación StringBuilder mejorar la velocidad del sistema, en segundo lugar, también se refiere a las operaciones de archivos relevantes, tenemos que utilizar IO arroyos y las operaciones conexas, y con el fin de permitir que los usuarios tengan una mejor interacción, la necesidad de utilizar la interfaz Java swing proporcionada por el final debido a la necesidad de analizar el rendimiento, necesitan utilizar la apropiada análisis de rendimiento artefacto JProfiler.
El análisis de clase
- clase CreatUtil: Crear operaciones relacionadas con la operación
- creat Método: ecuación generación aleatoria
- creatNum Método: operación de generación de números aleatorios
- creatSign Método: símbolos generados aleatoriamente
- método formulaNum: establecer un número de la ecuación generada aleatoriamente
- método numrange de: determinar si el operando supera un valor máximo
- categorías ProcessUtil: el proceso de cálculo de la correlación y la
- Métodos creatNum: La respuesta de acuerdo con las especificaciones generado a cabo
- mcd Método: buscando el máximo común divisor de dos números
- método charFind: una secuencia de bits almacenada en la fórmula carácter especificado
- changeNum métodos: la cadena numérica en un valor numérico
- Métodos Juez: La fórmula para determinar el cumplimiento con las especificaciones
- cambio de método: el denominador operando cadena de la molécula en digitales
- CalculateUtil categorías: Método de cálculo
- Agregar método: añadir
- menos Método: la resta
- método multiplican: multiplicación
- método de división: división
- método de cálculo: derecha e izquierda dos números símbolo de la operación aritmética
- método calculateFormula: Fórmula de cálculo
- categorías CheckUtil: ecuación de verificación (peso de verificación)
- spiltStringBuilderToArray Método: Split la matriz de fórmula general
- spiltStringBuilderToList Método: Lista array dividido en la ecuación
- spiltStringBuilderToOrderList Método: La ecuación de división en una matriz ordenada de Lista
- método judgeRepeat de: determinar si un contenido duplicado
- método FileDao:
- storageResult Método: almacenar los resultados en un archivo
- storageFile método: Procedimientos almacenados fórmulas y respuestas
- readFile método: leer el archivo
- Enumeración del operador: El operador con información sobre el paquete, para evitar una pluralidad de veces para reducir la eficacia de la nueva
- MainUI categorías: principal interacción página de usuario
- Los usuarios rellenan las páginas y otras operaciones relacionadas entre sí: la clase userui
5, Código Descripción
- clases CreatUtil: la clase empleada cambiado generación de números más al azar para implementar relativamente al azar, y tienen los datos de calibración necesarios en cada paso, para asegurar la precisión de datos.
@SuppressWarnings("all")
public class CreatUtil {
//日志输出
private static final Logger logger = Logger.getLogger("CreatUtil");
List<StringBuilder> formula;
//备份式子，存储"分子/分母"结构的式子，便于结果计算
List<StringBuilder> answer;
StringBuilder extraCopy ;
public List<StringBuilder> getFormula() {
return formula;
}
public List<StringBuilder> getAnswer() {
return answer;
}
/**
* 随机生成式子
* 用List存储式子
* @param maxNum 最大值
* @return 返回改字符串
* */
public StringBuilder creat(int maxNum) {
StringBuilder formula = new StringBuilder();
extraCopy = new StringBuilder(" ");
//符号个数 （1,2,3）
int signNum = (int)(Math.random()*3+1);
creatNum(formula,maxNum);
for(int i=0; i<signNum; i++) {
creatSign(formula);
creatNum(formula,maxNum);
}
formula.append(Operator.EQUAL_SIGN.getExpress() +" ");
return formula;
}
/**
* 随机生成操作数
* 并将操作数存入list中
* @param formula 字符串
* @param maxNum 数
* @return 返回参数的字符串
* */
public StringBuilder creatNum(StringBuilder formula,int maxNum) {
int numerator,denominator,type;
type = (int)(Math.random()*2);
//生成整数
if(type==0) {
do {
numerator =(int)(Math.random()*10);
}while(numerator > maxNum);
//备份分子/分母
extraCopy.append(numerator+"/"+1+" ");
formula.append(numerator+" ");
}
else {
do {
//随机生成分子
numerator = (int)(Math.random()*10);
//保证分母不等于0
while((denominator=(int)(Math.random()*10))==0);
}while(!numRange(numerator, denominator,maxNum));
//备份分子/分母
extraCopy.append(numerator+"/"+denominator+" ");
formula.append(ProcessUtil.creatNum(numerator, denominator));
}
return formula;
}
/**
* 随机生成符号
* 并将符号存入list中
* @param formula 符号
* @return 返回符号
*/
public StringBuilder creatSign(StringBuilder formula) {
//符号类型（+ - * /）
int signType = (int)(Math.random()*4+1);
switch (signType){
case 1 :
formula.append(Operator.PLUS_SIGN.getExpress());
extraCopy.append(Operator.PLUS_SIGN.getExpress());
break;
case 2 :
formula.append(Operator.MINUS_SIGN.getExpress());
extraCopy.append(Operator.MINUS_SIGN.getExpress());
break;
case 3 :
formula.append(Operator.MULTIPLIED_SIGN.getExpress());
extraCopy.append(Operator.MULTIPLIED_SIGN.getExpress());
break;
case 4 :
formula.append(Operator.DIVISION_SIGN.getExpress());
extraCopy.append(Operator.DIVISION_SIGN.getExpress());
break;
default:
}
extraCopy.append(" ");
formula.append(" ");
return formula;
}
/**
* 设定随机生成一定数目的式子，并将式子和答案分别存在formula和answer中
* @param num 生成的式子数目
* @param maxNum 最大值
*/
public void formulaNum(int num, int maxNum) throws IOException {
Long beginTime = System.currentTimeMillis();
//存放拆分完的式子
List<List<String>> formulaLists = new ArrayList<List<String>>(num);
formula = new ArrayList<StringBuilder>();
answer = new ArrayList<StringBuilder>();
//原始式子
StringBuilder singleFormula;
for(int i=0; formula.size()<num; i++) {
formula.add(singleFormula = creat(maxNum));
CalculateUtil.calculateFormula(extraCopy);
//式子不符合规范（结果为负数）,并且查重
if(extraCopy.charAt(0)=='@' || CheckUtil.judgeRepeat(singleFormula,formulaLists,extraCopy,answer)) {
formula.remove(formula.size()-1);
continue;
}
answer.add(extraCopy);
}
int i=0;
FileDao.storageFile(formula,"Exercises.txt");
FileDao.storageFile(answer,"Answers.txt");
System.out.println("生成时间: " + (System.currentTimeMillis()-beginTime));
}
/**
* 设定操作数的最大数值
* @param numerator 分子
* @param denominator 分母
* @param maxNum 最大值
* @return 是否超过最大值
*/
public boolean numRange(int numerator, int denominator,int maxNum) {
if((numerator/denominator)<maxNum) {
return true;
}else if((numerator/denominator)==maxNum) {
if((numerator%denominator)==0) {
return true;
}
}
return false;
}
}
- categorías CheckUtil: fórmulas para generar una suma de comprobación, la división de expresión, y después se compara, y también responde a la comparación, una doble garantía de la singularidad de la fórmula
@SuppressWarnings("all")
public class CheckUtil {
/**
* 将StringBuilder拆分成string数组
* @param stringBuilder
* @return 返回string[] 数组
*/
public static String[] spiltStringBuilderToArray(StringBuilder stringBuilder){
return stringBuilder.toString().split("\\s+");
}
/**
* 将StringBuilder拆分成List数组
* @param stringBuilder string串串
* @return 返回List数组
*/
public static List<String> spiltStringBuilderToList(StringBuilder stringBuilder){
return Arrays.asList(spiltStringBuilderToArray(stringBuilder));
}
/**
* 将StringBuilder拆分成有序的 List 数组
* @param stringBuilder string串串
* @return 返回List数组
*/
public static List<String> spiltStringBuilderToOrderList(StringBuilder stringBuilder){
List<String> stringList = spiltStringBuilderToList(stringBuilder);
Collections.sort(stringList);
return stringList;
}
/**
* 判断内容是否有重复
* @param formula 判断的式子
* @param lists 排序完的全部 list
* @param answer 答案
* @param answerLists 答案集
* @return 返回是否重复
*/
public static boolean judgeRepeat(StringBuilder formula, List<List<String>> lists,StringBuilder answer,List<StringBuilder> answerLists){
List<String> formulaList = spiltStringBuilderToOrderList(formula);
int i;
for (i = 0;i<lists.size();i++){
if(lists.get(i).equals(formulaList) && answer.toString().equals(answerLists.get(i).toString())){
return true;
}
}
lists.add(formulaList);
return false;
}
}
- categorías CalculateUtil: método de cálculo tirado habla para reducir el grado de acoplamiento, sino que también determina los datos para asegurar que la robustez del sistema
@SuppressWarnings("unused")
public class CalculateUtil {
private static final Logger logger = Logger.getLogger("CalculateUtil");
/**
* 加法运算
* @param numerator1 分子1
* @param denominator1 分母1
* @param numerator2 分子2
* @param denominator2 分母2
* @return 返回结果
*/
public static StringBuilder add(int numerator1,int denominator1,int numerator2,int denominator2) {
int numerator,denominator;
StringBuilder result = new StringBuilder();
numerator = numerator1*denominator2+numerator2*denominator1;
denominator = denominator1 * denominator2;
if(numerator!=0) {
//化简分子分母（除以最大公因数）
int gcdNum = ProcessUtil.gcd(numerator,denominator);
numerator /= gcdNum;
denominator /= gcdNum;
}
result.append(numerator+"/"+denominator);
return result;
}
/**
* 减法运算
* @param numerator1 分子1
* @param denominator1 分母1
* @param numerator2 分子2
* @param denominator2 分母2
* @return 返回计算结果
*/
public static StringBuilder minus(int numerator1,int denominator1,int numerator2,int denominator2) {
int numerator,denominator;
StringBuilder result = new StringBuilder();
numerator = numerator1*denominator2-numerator2*denominator1;
denominator = denominator1*denominator2;
//化简分子分母（除以最大公因数）
if(numerator!=0) {
int gcdNum = ProcessUtil.gcd(numerator,denominator);
numerator /= gcdNum;
denominator /= gcdNum;
}
result.append(numerator+"/"+denominator);
return result;
}
/**
* 乘法运算
* @param numerator1 分子1
* @param denominator1 分母1
* @param numerator2 分子2
* @param denominator2 分母2
* @return 返回计算结果
*/
public static StringBuilder multiply(int numerator1,int denominator1,int numerator2,int denominator2) {
int numerator,denominator;
StringBuilder result = new StringBuilder();
//操作数有一个等于0的情况
if(numerator1==0||numerator2==0) {
result.append(0+"/"+1);
}
//操作数大于0的情况
else {
numerator = numerator1*numerator2;
denominator = denominator1*denominator2;
//化简分子分母（除以最大公因数）
if(numerator!=0) {
int gcdNum = ProcessUtil.gcd(numerator,denominator);
numerator /= gcdNum;
denominator /= gcdNum;
}
result.append(numerator+"/"+denominator);
}
return result;
}
/**
* 除法运算
* @param numerator1 分子1
* @param denominator1 分母1
* @param numerator2 分子2
* @param denominator2 分母2
* @return 返回计算结果
*/
public static StringBuilder divide(int numerator1,int denominator1,int numerator2,int denominator2) {
int numerator,denominator;
StringBuilder result = new StringBuilder();
numerator = numerator1*denominator2;
denominator = denominator1*numerator2;
//化简分子分母（除以最大公因数）
if(numerator!=0) {
int gcdNum = ProcessUtil.gcd(numerator,denominator);
numerator /= gcdNum;
denominator /= gcdNum;
}
result.append(numerator+"/"+denominator);
return result;
}
/**
* 对运算符号左右的两个数进行运算
* @param index 运算符的位序
* @param extraCopy 待计算的式子
* @return
*/
public static StringBuilder calculate(int index,StringBuilder extraCopy) {
char sign = extraCopy.charAt(index);
int beginIndex = 0, endIndex = -1;
int[] datas = new int[3];
for(int index1=0; ; beginIndex=index1) {
//找到第一个操作数的开头空格
index1 = extraCopy.indexOf(" ", index1+1);
if(index1==(index-1)) {
break;
}
}
datas = ProcessUtil.change(extraCopy, beginIndex);
int numerator1 = datas[1];
int denominator1 = datas[2];
datas = new int[3];
datas = ProcessUtil.change(extraCopy, index+1);
int numerator2 = datas[1];
int denominator2 = datas[2];
endIndex = datas[0];
//删除数字部分
extraCopy.delete(beginIndex+1,endIndex);
//根据符号进行相应的运算
switch(sign){
case '+':
extraCopy.insert(beginIndex+1, add(numerator1,denominator1,numerator2,denominator2));
break;
case '-':
if(!ProcessUtil.judge(numerator1, denominator1, numerator2, denominator2)) {
//识别答案是否为负数
extraCopy.insert(0, "@ ");
break;
}
else{
extraCopy.insert(beginIndex+1, minus(numerator1,denominator1,numerator2,denominator2));
break;
}
case '*':
extraCopy.insert(beginIndex+1, multiply(numerator1,denominator1,numerator2,denominator2));
break;
case '÷':
if(numerator2 == 0) {
//识别答案是否为负数，是的话在开头插入@作为标识
extraCopy.insert(0, "@ ");
break;
}
else{
extraCopy.insert(beginIndex+1, divide(numerator1,denominator1,numerator2,denominator2));
break;
}
default: break;
}
return extraCopy;
}
/**
* 按优先级进行运算（* / + -）
* @param extraCopy copy副本
* @return 返回
*/
public static StringBuilder calculateFormula(StringBuilder extraCopy) {
// logger.info(extraCopy.toString());
//记录符号的位序
int index = -1;
//计算式子
Pattern pattern1 = Pattern.compile("[*]|[÷]");
Matcher m1;
while((m1 = pattern1.matcher(extraCopy)).find()) {
index = m1.start();
calculate(index, extraCopy);
if(extraCopy.charAt(0)=='@') {
break;
}
}
//如果式子正确，在进行加运算（从左到右）
if(extraCopy.charAt(0)!='@') {
Pattern pattern2 = Pattern.compile("[-]|[+]");
Matcher m2;
while((m2 = pattern2.matcher(extraCopy)).find()) {
index = m2.start();
calculate(index, extraCopy);
if(extraCopy.charAt(0)=='@') {
break;
}
}
}
//如果运算结束后（式子正确），调整答案格式
if(extraCopy.charAt(0)!='@') {
int datas[] = new int[3];
datas = ProcessUtil.change(extraCopy, 0);
int numerator = datas[1];
int denominator = datas[2];
//将原存储内容清空
extraCopy.setLength(0);
//将答案换成标准格式
extraCopy.append(ProcessUtil.creatNum(numerator, denominator));
}
return extraCopy;
}
}
- categorías ProcessUtil: proporcionar un momento y método de operación del proceso de cálculo para la informática proporciona un sólido respaldo
public class ProcessUtil {
/**
* 将答案按规范生成出来
* @param numerator 分子
* @param denominator 分母
* @return 式子
*/
public static StringBuilder creatNum(int numerator, int denominator) {
StringBuilder num = new StringBuilder();
int gcdNum = gcd(numerator, denominator);
numerator /= gcdNum;
denominator /= gcdNum;
if (numerator >= denominator) {
//分子大于等于分母
if (numerator % denominator == 0) {
//结果为整数
num.append(numerator / denominator + " ");
} else {
//结果为带分数
int interger = numerator / denominator;
numerator = numerator - (interger * denominator);
num.append(interger + "’" + numerator + "/" + denominator + " ");
}
} else {
//分子小于分母
if (numerator == 0) {
//分子小于0
num.append(0 + " ");
} else {
//其他情况
num.append(numerator + "/" + denominator + " ");
}
}
return num;
}
/**
* 求两数的最大公因数
* @param num01 数字1
* @param num02 数字2
* @return 返回公因数
*/
public static int gcd(int num01, int num02) {
int num = 0;
while (num02 != 0) {
num = num01 % num02;
num01 = num02;
num02 = num;
}
return num01;
}
/**
* 将式子中指定字符的所有位序存储起来
* @param str 字符串
* @param formula 式子
* @return 返回位序
*/
public static int[] charFind(String str, StringBuilder formula) {
int[] indexs = new int[20];
for (int i = 0; ; i++) {
if (i == 0) {
indexs[i] = formula.indexOf(str, 0);
continue;
}
if (str.equals(" ") && (indexs[i - 1] == formula.length() - 1)) {
break;
}
if (str.equals(" ") || str.equals("/")) {
indexs[i] = formula.indexOf(str, indexs[i - 1] + 1);
}
if (str.equals("/") && (formula.length() - 1 - indexs[i] <= 4)) {
break;
}
}
return indexs;
}
/**
* 将指定数字字符串转为数字值
* @param formula 带查找的式子
* @param fromIndex 操作数前的空格位序
* @param endIndex 操作数后的空格位序
* @return 返回数字
*/
public static int changeNum(StringBuilder formula, int fromIndex, int endIndex) {
int num = -1;
//根据数字的位数进行转换
int sum = 0, temp;
for (int i = 1; i < (endIndex - fromIndex); i++) {
temp = (int) Math.pow((double) 10, (double) (i - 1));
num = (int) (formula.charAt(endIndex - i) - 48) * temp;
sum += num;
}
return sum;
}
/**
* 判断被减数、减数是否符合规范(true:符合；false:不符合)
* @param numerator1 第一个操作数的分子
* @param denominator1 第一个操作数的分母
* @param numerator2 第二个操作数的分子
* @param denominator2 第二个操作数的分母
* @return 返回是否正确
*/
public static boolean judge(int numerator1, int denominator1, int numerator2, int denominator2) {
int numerator = numerator1 * denominator2 - numerator2 * denominator1;
if (numerator < 0) {
return false;
}
return true;
}
/**
* 通过字符串将操作数的分子分母转成数字
* @param extraCopy 进行操作的字符串
* @param beginIndex 操作数前的空格位序
* @return 返回数字集
*/
public static int[] change(StringBuilder extraCopy, int beginIndex) {
int[] num = new int[3];
int[] blanks = charFind(" ", extraCopy);//存储空格的位序，方便找到完整的操作数
int indexBl = -1 ,indexBa ;
indexBa = extraCopy.indexOf("/", beginIndex);//反斜杠的位置
for(int i=0; i<blanks.length; i++) {
if(blanks[i]==beginIndex) {//找到传入空格位序在blanks中的位置
indexBl = i;
break;
}
}
num[0]=blanks[indexBl+1];//操作数后的空格位序
num[1]=changeNum(extraCopy,beginIndex,indexBa);//分子
num[2]=changeNum(extraCopy,indexBa,num[0]);//分母
return num;
}
}
- FileDao categorías: los archivos de importación y exportación encapsulado, es decir, las operaciones de persistencia de datos, hay un método para el formato de archivo determinan que corresponde a eliminar la ocurrencia de alguna anormalidad
public class FileDao {
private static final String PATH = System.getProperty("user.dir");
/**
* 输出信息导文件中
* @param list 输入的内容
* @param fileName 输入的文件名
* @return 返回是否成功
*/
public static boolean storageFile(List<StringBuilder> list, String fileName) {
File file = new File(PATH + "\\" +fileName);
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(file,false);
String content = "";
for (int i =0 ;i<list.size();i++){
content = content + (i+1) + "、" + list.get(i).toString() + "\n";
}
fileOutputStream.write(content.getBytes());
} catch (IOException e) {
e.printStackTrace();
return false;
}finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return true;
}
/**
* 阅读用户传入的文件
* @param file 传入的文件
* @return 返回一个List集合
*/
public static List<StringBuilder> readFile(File file) {
List<StringBuilder> list = new ArrayList<>();
FileInputStream fileInputStream = null;
BufferedReader bufferedReader = null;
//判断文件类型是否正确
if (!file.exists() || !file.getName().contains("txt")){
return null;
}
try {
fileInputStream = new FileInputStream(file);
bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
String raw;
for (int i = 0; null != (raw = bufferedReader.readLine()); i++) {
//文件内容是否有、，分情况输出
if (raw.contains("、")) {
list.add(new StringBuilder(raw.substring(raw.indexOf("、") + 1, raw.length() - 1)));
} else {
list.add(new StringBuilder(raw));
}
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
fileInputStream.close();
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return list;
}
}
- Enumeración del operador: El operador sencilla encapsulación
public enum Operator {
/**
* 运算符
*/
PLUS_SIGN("加号","+","+"),
MINUS_SIGN("减号","-","-"),
MULTIPLIED_SIGN("乘以号","*","*"),
DIVISION_SIGN("除以号","÷","/"),
EQUAL_SIGN("等于号","=","=");
private String name;
private String express;
private String calculation;
Operator(String name, String express, String calculation) {
this.name = name;
this.express = express;
this.calculation = calculation;
}
public String getName() {
return name;
}
public String getExpress() {
return express;
}
public String getCalculation() {
return calculation;
}
}