结对开发

源程序代码:

Cal.java:

package caculator_core;

 

import java.util.HashSet;

import java.util.Random;

import java.util.Scanner;

 

public class Calc {

 

public static void main(String[] args) {

System.out.println("-------输入0选择默认配置,输入1选择自定义配置-------");

Scanner scanner = new Scanner(System.in);

CalCore calCore = new CalCore();

int number = scanner.nextInt();

switch (number) {

case 0:

calCore =new CalCore();

break;

case 1:

System.out.println("-------请输入运算符总数------");

int numberTotal = scanner.nextInt();

System.out.println("-------请输入运算式个数------");

int formulaTotal = scanner.nextInt();

System.out.println("-------请输入最大运算数字------");

int numberRange = scanner.nextInt();

System.out.println("-------请输入运算结果最大值------");

int maxResult = scanner.nextInt();

System.out.println("-------是否包含乘除法------");

boolean includeMulAndDiv = false;

if(scanner.next().equals("是")) {

includeMulAndDiv = true;

}else {

includeMulAndDiv = false;

}

System.out.println("-------是否包含负数------");

boolean includeNegNum = false;

if(scanner.next().equals("是")) {

includeNegNum = true;

}else {

includeNegNum = false;

}

calCore = new CalCore(numberTotal,formulaTotal,numberRange,maxResult,includeMulAndDiv,includeNegNum);

default:

break;

}

 

HashSet<String> formulas = calCore.generateFormulas();

double [] arr = calCore.generateAnswers(formulas);

System.out.println(calCore.outputFormulas(formulas));

System.out.println(calCore.outputAnswers(arr));

}

}

CalCore.java:

package caculator_core;

 

import java.io.File;

import java.io.FileWriter;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.HashSet;

import java.util.Random;

import java.util.Stack;

 

 

public class CalCore {

 

//运算符总数

private int numberTotal;

//运算式个数

private int formulaTotal;

//数字范围

private int numberRange;

//运算结果最大值

private int maxResult;

//是否包含乘除法

private boolean includeMulAndDiv;

//是否包含负数

private boolean includeNegNum;

public CalCore() {

this.numberTotal = 2;

this.formulaTotal = 10;

this.numberRange = 100;

this.maxResult = 100;

this.includeMulAndDiv =false;

this.includeNegNum = false;

}

public CalCore(int numberTotal,int formulaTotal,int numberRange,int maxResult,boolean includeMulAndDiv,boolean includeNegNum) {

this.numberTotal = numberTotal;

this.formulaTotal = formulaTotal;

this.numberRange = numberRange;

this.maxResult = maxResult;

this.includeMulAndDiv = includeMulAndDiv;

this.includeNegNum = includeNegNum;

}

//生成随机数

public double getRandomNumber() {

Random random = new Random();

 

if(this.includeNegNum) {

double d = (random.nextInt(this.numberRange)+1)*(random.nextDouble()>0.5?1.0:-1.0)*(random.nextDouble());

BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);

return bg.doubleValue();

}else {

double d =(random.nextInt(this.numberRange)+1)*(random.nextDouble());

BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);

return bg.doubleValue();

}

}

//生成随机运算符

public String getRandomOperator() {

Random random = new Random();

String [] opreations = {"+","-","*","/"};

return opreations[random.nextInt((this.includeMulAndDiv == true)?4:2)];

}

//生成算式

public String generateFormula() {

String formula ="";

for(int i=0;i<this.numberTotal;i++) {

if(i>=this.numberTotal-1) {

formula += isNegNum(this.getRandomNumber());

continue;

}

formula += isNegNum(this.getRandomNumber())+" "+this.getRandomOperator() +" ";

}

return formula;

}

//如果负数就加括号

private String isNegNum(double randomNumber) {

if(randomNumber<0) {

return "("+randomNumber +")";

}

return ""+randomNumber;

}

//生成算式集合

public HashSet<String> generateFormulas(){

HashSet<String> set = new HashSet<String>();

while(set.size()<=this.formulaTotal) {

String formula = this.generateFormula();

if(this.maxResult>= getAnswer(formula)) {

set.add(formula);

}

}

return set;

}

//生成答案

public double[] generateAnswers(HashSet<String> set) {

double [] arr = new double[set.size()];

int i=0;

for(String str:set) {

arr[i++] = getAnswer(str);

}

return arr;

}

//打印算式

public String outputFormulas(HashSet<String> set) {

File file = new File("result.txt");

try {

FileWriter fw = new FileWriter(file);

for(String str:set) {

System.out.println(str);

fw.write(str+"\n");

}

fw.close();

} catch (Exception e) {

System.out.println("Error"+e.getMessage());

System.exit(0);

}

return file.getAbsolutePath();

}

//打印答案

public String outputAnswers(double[]arr) {

File file = new File("answer.txt");

try {

FileWriter fw = new FileWriter(file);

for(int i=0;i<arr.length;i++) {

fw.write(arr[i]+"\n");

}

fw.close();

} catch (Exception e) {

System.out.println("Error"+e.getMessage());

System.exit(0);

}

return file.getAbsolutePath();

}

public  Double getAnswer(String formula) {

int length=0;

String [] formulaArr = formula.split(" ");

String operators = "+-*/";

Stack<Double> opNumbers = new Stack<Double>();

Stack<String> opOperators = new Stack<String>();

opOperators.add("#");//字符栈存个#,防止栈空

while(length<formulaArr.length) {

String op = formulaArr[length++];

//如果是运算符，判断优先级

//indexof方法,判断字符串第一次出现的位置，找不到为-1

if(operators.indexOf(op) >-1) {

String sign = opOperators.peek();//顶部出栈

int priority = compare(op,sign);//比较优先级

if(priority>=0) {//如果要入栈的运算符优先级高或相等,出栈两个数字，和之前的运算符计算后数字和字符分别入栈

opNumbers.add(compute(opOperators,opNumbers));

opOperators.add(op);

}else {//入栈运算符优先级低，直接入栈

opOperators.add(op);

 

}

continue;

}

//若是数字，则入栈

opNumbers.add(Double.parseDouble(op.replace("(", "").replace(")", "")));//将括号忽略掉

}

while (opOperators.peek()!="#") {

opNumbers.add(compute(opOperators, opNumbers));

}

return opNumbers.pop();

 

}

 

private  Double compute(Stack<String> opOperators, Stack<Double> opNumbers) {

double num2 = opNumbers.pop();

double num1 = opNumbers.pop();

String _op = opOperators.pop();

double result =0.0;

switch(_op) {

case "+":

result=num1+num2;

break;

case "-":

result =num1-num2;

break;

case "*":

result =num1*num2;

break;

case "/":

result =num1/num2;

break;

}

BigDecimal bg = new BigDecimal(result).setScale(2, RoundingMode.UP);

result = bg.doubleValue();

return result;

}

 

private  int compare(String operator1, String operator2) {

int res=0;

switch(operator1) {

case "+":

case "-":

if(operator2.equals("+")||operator2.equals("-")||operator2.equals("*")||operator2.equals("/")) {

res=1;

}else {

res=-1;

}

break;

case "*":

case "/":

if(operator2.equals("*")||operator2.equals("/")) {

res=1;

}else {

res=-1;

}

break;

}

return res;

}

}

运行截图: