记录一个很抽象的简单计算器代码
·
小孩子不懂事写着玩的
package com.qs.h114514;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class test1 {
public static void main(String[] args) {
String s114514 = "114514";
String[] sfh = {"+", "-", "*", "/"};
// 初始化结果字符串，以s114514的第一个字符开始
StringBuilder result = new StringBuilder(s114514.charAt(0) + "");
// 遍历s114514中除了第一个和最后一个字符以外的每个字符
for (int i = 1; i < s114514.length() - 1; i++) {
// 随机选择一个运算符插入
// 注意：为了简单起见，这里使用随机选择，但你也可以根据需要选择特定的运算符
int randomIndex = (int) (Math.random() * sfh.length);
result.append(sfh[randomIndex]);
// 将当前遍历到的数字添加到结果字符串中
result.append(s114514.charAt(i));
}
// 添加s114514的最后一个字符
result.append(s114514.charAt(s114514.length() - 1));
String[] s1 = splitExpression(result.toString());//将字符串转换为字符串数组
//将字符串数组中*/两边的数字用（）括起来；
s1=ttt1(s1,0);
System.out.println("最终：");
for (int i = 0; i < s1.length; i++) {
System.out.print(s1[i]);
}
//进行拆解运算（）优先，
System.out.println("="+t1(s1));
}
public static String[] ttt1(String[] sss1 ,int index){
System.out.println("---------------------------------------------------");
System.out.println("开始索引为"+index+" 开始字符为:"+sss1[index]);
System.out.println("当前算式为：");
for (int i = 0; i < sss1.length; i++) {
System.out.print(sss1[i]);
}
System.out.println();
if (index>sss1.length){
return sss1;
}
int indexofright=index-1;
int indexofleft=index+2;
// newstr=sss1;
////将字符串数组中*/两边的数字或者被括号括起来的算式用（）括起来；
//例如，将"2*3+5*(2+3)*(1+1)"转换为"(2*3)+((5*(2+3))*(1+1))"
for (int i = index; i < sss1.length; i++) {
if (sss1[i].equals("*")||sss1[i].equals("/")){
String[] newstr=new String[sss1.length+2];
if (sss1[i+1].equals("(")){
int count=1;
for (int i1 = i+2; i1 < sss1.length; i1++) {
if (sss1[i1].equals("(")){
count++;
}
if (sss1[i1].equals(")")){
indexofright=i1+1;
count--;
// System.out.println(")"+indexofright);
if (count==0) {
break;
}
}
}
}else {
indexofright=i+2;
}
if (sss1[i-1].equals(")")){
int count=1;
for (int i1 = i-2; i1 >=0; i1--) {
if (sss1[i1].equals(")")){
count++;
}
if (sss1[i1].equals("(")){
indexofleft=i1;
count--;
if (count==0) {
break;
}
}
}
}else {
indexofleft=i-1;
}
System.out.println("当前要添加（的坐标为: " + indexofleft);
System.out.println("当前要添加)的坐标为: " + indexofright);
for (int i1 = 0; i1 < newstr.length; i1++) {
if(i1<indexofleft){
newstr[i1]=sss1[i1];
}else if (i1==indexofleft){
// System.out.println("left:"+i1);
newstr[i1]="(";
} else if (i1<indexofright+1) {
newstr[i1]=sss1[i1-1];
}else if (i1==indexofright+1){
newstr[i1]=")";
}else {
newstr[i1]=sss1[i1-2];
}
System.out.print(newstr[i1]);
}
System.out.println("----");
return ttt1(newstr,indexofright+1);
// newstr=ttt1(newstr,indexofright+1);
}
}
return sss1;
}
public static double t1(String[] sss1){
double resultsss=0;
int indexofright = 0;
for (int i = 0; i < sss1.length-2; ) {
if (!Objects.equals(sss1[i], "(")){
double n1 = Double.parseDouble(sss1[i]); // 使用 Double.parseDouble()
String fh = sss1[i + 1];
if (!Objects.equals(sss1[i+2], "(")) {
double n2 = Double.parseDouble(sss1[i + 2]);
resultsss = caclAll(n1, fh, n2);
sss1[i + 2] = String.valueOf(resultsss);
i += 2;
}else {
int count=1;
for (int j1=i+3;j1<sss1.length;j1++){
if (Objects.equals(sss1[j1],"(")){
count++;
}
if (Objects.equals(sss1[j1], ")")){
indexofright=j1;//获取右括号的index
count--;
if (count==0) {
break;
}
}
}
String[] st1=new String[indexofright-(i+3)];//新建一个数组来存括号里的数据
for (int i1 = 0; i1 < st1.length; i1++) {
st1[i1]=sss1[i+3+i1];
}
double n2=t1(st1);
resultsss = caclAll(n1, fh, n2);
sss1[indexofright]= String.valueOf(resultsss);
i=indexofright;
}
}
else {
int count=1;
for (int i1 = i+1; i1 < sss1.length; i1++) {
if (Objects.equals(sss1[i1],"(")){
count++;
}
if (Objects.equals(sss1[i1], ")")){
indexofright=i1;//获取右括号的index
// System.out.println("indexofright:"+indexofright);
count--;
if (count==0) {
break;
}
}
}
String[] st1=new String[indexofright-(i+1)];//新建一个数组来存括号里的数据
for (int i1 = 0; i1 < st1.length; i1++) {
st1[i1]=sss1[i+1+i1];
// System.out.println("st1["+i1+"]"+st1[i1]);
}
double n1=t1(st1);
i=indexofright;
String fh=sss1[i+1];
if (!Objects.equals(sss1[i+2], "(")) {
double n2 = Double.parseDouble(sss1[i + 2]);
resultsss = caclAll(n1, fh, n2);
sss1[i + 2] = String.valueOf(resultsss);
i += 2;
}else {
int count1=1;
for (int j1=i+3;j1<sss1.length;j1++){
if (Objects.equals(sss1[j1],"(")){
count1++;
}
if (Objects.equals(sss1[j1], ")")){
indexofright=j1;//获取右括号的index
count1--;
if (count1==0) {
break;
}
}
}
String[] st2=new String[indexofright-(i+3)];//新建一个数组来存括号里的数据
for (int i1 = 0; i1 < st2.length; i1++) {
st2[i1]=sss1[i+3+i1];
}
double n2=t1(st2);
resultsss = caclAll(n1, fh, n2);
sss1[indexofright]= String.valueOf(resultsss);
i=indexofright;
}
}
}
return resultsss;
}
// public double t1()
public static String[] splitExpression(String expression) {
StringBuilder currentPart = new StringBuilder();
List<String> parts = new ArrayList<>();
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (Character.isDigit(c)) {
// 如果当前字符是数字，则将其添加到当前部分
currentPart.append(c);
} else {
// 如果当前字符不是数字，则先检查当前部分是否非空
if (currentPart.length() > 0) {
// 如果当前部分非空，则将其添加到列表中，并重置当前部分
parts.add(currentPart.toString());
currentPart = new StringBuilder();
}
// 将运算符（或括号）添加到列表中
parts.add(String.valueOf(c));
}
}
// 循环结束后，检查并添加最后一个数字部分（如果有的话）
if (currentPart.length() > 0) {
parts.add(currentPart.toString());
}
// 将列表转换为数组并返回
return parts.toArray(new String[0]);
}
public static double caclAll(double number1, String s, double number2) {
return switch (s) {
case "+" -> number1 + number2;
case "-" -> number1 - number2;
case "*" -> number1 * number2;
case "/" -> (double) number1 / number2;
default -> 0;
};
}
}
下面的是改良版
package com.qs.h114514;
import java.util.*;
public class test1 {
// 运算符优先级映射表
private static final Map<String, Integer> OPERATOR_PRECEDENCE = new HashMap<>();
static {
OPERATOR_PRECEDENCE.put("+", 1);
OPERATOR_PRECEDENCE.put("-", 1);
OPERATOR_PRECEDENCE.put("*", 2);
OPERATOR_PRECEDENCE.put("/", 2);
OPERATOR_PRECEDENCE.put("(", 0);
OPERATOR_PRECEDENCE.put(")", 0);
}
public static void main(String[] args) {
String s114514 = "114514";
String[] operators = {"+", "-", "*", "/"};
Random random = new Random();
// 生成随机表达式
StringBuilder exprBuilder = new StringBuilder();
exprBuilder.append(s114514.charAt(0));
for (int i = 1; i < s114514.length(); i++) {
int opIndex = random.nextInt(operators.length);
exprBuilder.append(operators[opIndex]);
exprBuilder.append(s114514.charAt(i));
}
String expression = exprBuilder.toString();
System.out.println("原始表达式: " + expression);
// 添加括号以确保运算顺序
String bracketedExpr = addBrackets(expression);
System.out.println("添加括号后: " + bracketedExpr);
// 计算结果
double result = evaluateExpression(bracketedExpr);
System.out.println("计算结果: " + result);
}
// 添加括号以确保乘除优先
private static String addBrackets(String expr) {
List<String> tokens = tokenize(expr);
List<String> output = new ArrayList<>();
Stack<String> stack = new Stack<>();
for (String token : tokens) {
if (isNumber(token)) {
output.add(token);
} else if (token.equals("(")) {
stack.push(token);
} else if (token.equals(")")) {
while (!stack.peek().equals("(")) {
output.add(stack.pop());
}
stack.pop(); // 弹出左括号
} else { // 运算符
while (!stack.isEmpty() &&
OPERATOR_PRECEDENCE.get(stack.peek()) >= OPERATOR_PRECEDENCE.get(token)) {
output.add(stack.pop());
}
stack.push(token);
}
}
// 弹出剩余运算符
while (!stack.isEmpty()) {
output.add(stack.pop());
}
// 转换为中缀表达式并添加括号
return toInfixWithBrackets(output);
}
// 将后缀表达式转换为带括号的中缀表达式
private static String toInfixWithBrackets(List<String> postfix) {
Stack<String> stack = new Stack<>();
for (String token : postfix) {
if (isNumber(token)) {
stack.push(token);
} else { // 运算符
String right = stack.pop();
String left = stack.pop();
stack.push("(" + left + token + right + ")");
}
}
return stack.pop();
}
// 计算表达式的值
private static double evaluateExpression(String expr) {
List<String> tokens = tokenize(expr);
Stack<Double> numbers = new Stack<>();
Stack<String> operators = new Stack<>();
for (String token : tokens) {
if (isNumber(token)) {
numbers.push(Double.parseDouble(token));
} else if (token.equals("(")) {
operators.push(token);
} else if (token.equals(")")) {
while (!operators.peek().equals("(")) {
numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
}
operators.pop(); // 弹出左括号
} else { // 运算符
while (!operators.isEmpty() &&
OPERATOR_PRECEDENCE.get(operators.peek()) >= OPERATOR_PRECEDENCE.get(token)) {
numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
}
operators.push(token);
}
}
// 处理剩余的运算符
while (!operators.isEmpty()) {
numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
}
return numbers.pop();
}
// 应用运算符进行计算
private static double applyOperation(String operator, double b, double a) {
switch (operator) {
case "+": return a + b;
case "-": return a - b;
case "*": return a * b;
case "/":
if (b == 0) throw new UnsupportedOperationException("Cannot divide by zero");
return a / b;
}
throw new IllegalArgumentException("Invalid operator: " + operator);
}
// 将表达式分词
private static List<String> tokenize(String expr) {
List<String> tokens = new ArrayList<>();
StringBuilder number = new StringBuilder();
for (char c : expr.toCharArray()) {
if (Character.isDigit(c)) {
number.append(c);
} else {
if (number.length() > 0) {
tokens.add(number.toString());
number.setLength(0);
}
tokens.add(Character.toString(c));
}
}
if (number.length() > 0) {
tokens.add(number.toString());
}
return tokens;
}
// 判断字符串是否为数字
private static boolean isNumber(String s) {
try {
Double.parseDouble(s);
return true;
} catch (NumberFormatException e) {
return false;
}
}
}
DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐
20
0- 0
已为社区贡献1条内容
所有评论(0)