Java语言怎么输入一个表达式，表达式包括了数字和符号还有括号，输出这个表达式的计算结果，表达式怎么计算的呢
Java语言怎么输入一个表达式，表达式包括了数字和符号还有括号，输出这个表达式的计算结果，表达式怎么计算的呢
这个刚才有个同样的问题哈, 我直接拿过来了, 你看任何一个都可以
效果图 :
代码 :
public class QuadraticEquation {
public static void main(String[] args) {
double a = 2.0;
double b = -5.0;
double c = 2.0;
// 输出二次方程的系数
System.out.println("二次方程的系数:");
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
// 计算判别式
double discriminant = b * b - 4 * a * c;
System.out.println("判别式(Discriminant) = " + discriminant);
// 判断根的情况并计算根
if (discriminant > 0) {
double root1 = (-b + Math.sqrt(discriminant)) / (2 * a);
double root2 = (-b - Math.sqrt(discriminant)) / (2 * a);
System.out.println("有两个实数根:");
System.out.println("根1 = " + root1);
System.out.println("根2 = " + root2);
} else if (discriminant == 0) {
double root = -b / (2 * a);
System.out.println("有一个实数根:");
System.out.println("根 = " + root);
} else {
System.out.println("没有实数根.");
}
}
}
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class ExpressionEvaluator {
public static void main(String[] args) {
String expression = "(2 + 3) * 4 - 5"; // 表达式示例
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
try {
Object result = engine.eval(expression);
System.out.println("计算结果: " + result);
} catch (ScriptException e) {
e.printStackTrace();
}
}
}
- 你可以看下这个问题的回答https://ask.csdn.net/questions/1084076
- 这篇博客你也可以参考下：【Java】在控制台输入一个整数，编写一个程序计算该整数的的各位数字之和。
- 同时，你还可以查看手册：java-学习Java语言 - 描述Java编程语言的基本概念和特点的课程。-类和对象》描述了如何编写创建对象的类，以及如何创建和使用对象。-更多关于课程的信息 中的内容
- 除此之外, 这篇博客: 【Java数据结构与算法】排序七大算法，包括冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序中的 七、基数排序 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
基数排序(Radix Sort)是桶排序的扩展
基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
import java.util.Arrays; public class RadixSort { public static void main(String[] args) { int arr[] = { 53, 3, 542, 748, 14, 214}; radixSort(arr); System.out.println("基数排序后 " + Arrays.toString(arr)); } //基数排序方法 public static void radixSort(int[] arr) { //根据前面的推导过程，我们可以得到最终的基数排序代码 //1. 得到数组中最大的数的位数 int max = arr[0]; //假设第一数就是最大数 for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } //得到最大数是几位数 int maxLength = (max + "").length(); //定义一个二维数组，表示10个桶, 每个桶就是一个一维数组 //说明 //1. 二维数组包含10个一维数组 //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length //3. 明确，基数排序是使用空间换时间的经典算法 int[][] bucket = new int[10][arr.length]; //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数 //可以这里理解 //比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数 int[] bucketElementCounts = new int[10]; //这里我们使用循环将代码处理 for (int i = 0, n = 1; i < maxLength; i++, n *= 10) { for (int j = 0; j < arr.length; j++) { //取出每个元素的个位的值 int digitOfElement = arr[j] / n % 10;//n=1,=10,=100,就可以拿出个位数，十位数和百位数了 //放入到对应的桶中,取出的个位值就正好放入二位数组的下标对应的地方，比如取出是2，刚好就放入二维数组下标为2的一维数组里 //而bucket第2个值，初始是0，第一次放入就是[3][0],然后后面++，记录整个个位数下标的数组值就会加1，如果再次放入数据，位置就是[3][1] bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j]; bucketElementCounts[digitOfElement]++; } //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组) int index = 0; //遍历每一桶，并将桶中的数据，放入到原数组 for (int k = 0; k < bucket.length; k++) { //如果桶中，有数据，我们才放入到原数组 if (bucketElementCounts[k] != 0) { //循环该桶即第k个桶(即第k个一维数组), 放入 for (int l = 0; l < bucketElementCounts[k]; l++) { //取出元素放入到arr arr[index++] = bucket[k][l]; } } //第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ //因为如果不清零会影响下一位数的判断 bucketElementCounts[k] = 0; } } } /* //第1轮(针对每个元素的个位进行排序处理) for(int j = 0; j < arr.length; j++) { //取出每个元素的个位的值 int digitOfElement = arr[j] / 1 % 10; //放入到对应的桶中 bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j]; bucketElementCounts[digitOfElement]++; } //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组) int index = 0; //遍历每一桶，并将桶中是数据，放入到原数组 for(int k = 0; k < bucketElementCounts.length; k++) { //如果桶中，有数据，我们才放入到原数组 if(bucketElementCounts[k] != 0) { //循环该桶即第k个桶(即第k个一维数组), 放入 for(int l = 0; l < bucketElementCounts[k]; l++) { //取出元素放入到arr arr[index++] = bucket[k][l]; } } //第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ bucketElementCounts[k] = 0; } System.out.println("第1轮，对个位的排序处理 arr =" + Arrays.toString(arr)); */ }- 您还可以看一下 徐无忌老师的Java进阶高手课-深入浅出Java网络编程课程中的 案例实战：浏览器打开一个网址，整个过程是怎么样的？小节, 巩固相关知识点
- 以下回答由chatgpt基于相关博客总结生成:
问题: Java语言中如何输入一个包含数字、符号和括号的表达式，并输出表达式的计算结果？
解决方案: 1. 使用Scanner类从键盘读取用户输入的表达式。 2. 创建一个栈来保存运算符和括号。 3. 使用循环遍历表达式的每个字符。 4. 对于每个字符，根据其类型进行不同的处理: - 如果是数字，则将其加入到一个临时变量中，以便处理多位数。 - 如果是运算符或括号，则将其压入栈中。 - 如果是空格，则忽略。 - 如果是其他字符，则表示一个完整的数字，将临时变量转换为数字并将其压入栈中。 5. 当处理完整个表达式后，栈中应该只包含数字和运算符。 6. 创建一个辅助栈来保存运算过程中的中间结果。 7. 遍历栈中的元素，通过判断运算符的优先级和结合性，进行相应的运算，并将结果压入辅助栈中。 8. 最后，在辅助栈中的顶部元素即为表达式的计算结果。
下面是示例代码的实现:
import java.util.Scanner; import java.util.Stack; public class ExpressionCalculator { public static boolean isOperator(char ch) { return ch == '+' || ch == '-' || ch == '*' || ch == '/'; } public static boolean isOperand(char ch) { return ch >= '0' && ch <= '9'; } public static int performOperation(int operand1, int operand2, char operator) { switch (operator) { case '+': return operand1 + operand2; case '-': return operand1 - operand2; case '*': return operand1 * operand2; case '/': return operand1 / operand2; default: return 0; } } public static int evaluateExpression(String expression) { Stack<Integer> operandStack = new Stack<>(); Stack<Character> operatorStack = new Stack<>(); for (int i = 0; i < expression.length(); i++) { char ch = expression.charAt(i); if (ch == ' ') { continue; } else if (isOperand(ch)) { int operand = 0; while (i < expression.length() && isOperand(expression.charAt(i))) { operand = operand * 10 + (expression.charAt(i) - '0'); i++; } i--; operandStack.push(operand); } else if (isOperator(ch)) { while (!operatorStack.empty() && operatorStack.peek() != '(' && hasHigherPrecedence(operatorStack.peek(), ch)) { int operand2 = operandStack.pop(); int operand1 = operandStack.pop(); char operator = operatorStack.pop(); int result = performOperation(operand1, operand2, operator); operandStack.push(result); } operatorStack.push(ch); } else if (ch == '(') { operatorStack.push(ch); } else if (ch == ')') { while (!operatorStack.empty() && operatorStack.peek() != '(') { int operand2 = operandStack.pop(); int operand1 = operandStack.pop(); char operator = operatorStack.pop(); int result = performOperation(operand1, operand2, operator); operandStack.push(result); } if (!operatorStack.empty()) { operatorStack.pop(); // Remove the opening bracket } } } while (!operatorStack.empty()) { int operand2 = operandStack.pop(); int operand1 = operandStack.pop(); char operator = operatorStack.pop(); int result = performOperation(operand1, operand2, operator); operandStack.push(result); } return operandStack.peek(); } public static boolean hasHigherPrecedence(char operator1, char operator2) { if ((operator1 == '*' || operator1 == '/') && (operator2 == '+' || operator2 == '-')) { return true; } return false; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入一个包含数字、符号和括号的表达式:"); String expression = scanner.nextLine(); int result = evaluateExpression(expression); System.out.println("表达式的计算结果为: " + result); } }你可以在命令行中运行这段代码，并输入一个表达式进行测试。
注: 上述代码使用了两个栈，一个用于保存操作数，一个用于保存操作符和括号。算法的基本思路是，根据运算符的优先级和结合性，使用两个栈来模拟表达式的计算过程。通过遍历表达式的每个字符，将操作数和操作符依次压入栈中。然后，通过比较栈顶的操作符的优先级和当前操作符的优先级，来判断是否需要进行计算，并将结果压入栈中。最后，在栈中只剩下一个元素时，即为表达式的计算结果。