java计算字符串公式计算

㈠ java 字符串算术表达式求值

Java 字符串算术表达式求值:
import java.util.ArrayList;
import java.util.Stack;

/**
*
* @author yhh
*
*/
public class Calculate {

/**
* 将字符串转化成List
* @param str
* @return
*/
public ArrayList<String> getStringList(String str){
ArrayList<String> result = new ArrayList<String>();
String num = "";
for (int i = 0; i < str.length(); i++) {
if(Character.isDigit(str.charAt(i))){
num = num + str.charAt(i);
}else{
if(num != ""){
result.add(num);
}
result.add(str.charAt(i) + "");
num = "";
}
}
if(num != ""){
result.add(num);
}
return result;
}

/**
* 将中缀表达式转化为后缀表达式
* @param inOrderList
* @return
*/
public ArrayList<String> getPostOrder(ArrayList<String> inOrderList){

ArrayList<String> result = new ArrayList<String>();
Stack<String> stack = new Stack<String>();
for (int i = 0; i < inOrderList.size(); i++) {
if(Character.isDigit(inOrderList.get(i).charAt(0))){
result.add(inOrderList.get(i));
}else{
switch (inOrderList.get(i).charAt(0)) {
case '(':
stack.push(inOrderList.get(i));
break;
case ')':
while (!stack.peek().equals("(")) {
result.add(stack.pop());
}
stack.pop();
break;
default:
while (!stack.isEmpty() && compare(stack.peek(), inOrderList.get(i))){
result.add(stack.pop());
}
stack.push(inOrderList.get(i));
break;
}
}
}
while(!stack.isEmpty()){
result.add(stack.pop());
}
return result;
}

/**
* 计算后缀表达式
* @param postOrder
* @return
*/
public Integer calculate(ArrayList<String> postOrder){
Stack stack = new Stack();
for (int i = 0; i < postOrder.size(); i++) {
if(Character.isDigit(postOrder.get(i).charAt(0))){
stack.push(Integer.parseInt(postOrder.get(i)));
}else{
Integer back = (Integer)stack.pop();
Integer front = (Integer)stack.pop();
Integer res = 0;
switch (postOrder.get(i).charAt(0)) {
case '+':
res = front + back;
break;
case '-':
res = front - back;
break;
case '*':
res = front * back;
break;
case '/':
res = front / back;
break;
}
stack.push(res);
}
}
return (Integer)stack.pop();
}

/**
* 比较运算符等级
* @param peek
* @param cur
* @return
*/
public static boolean compare(String peek, String cur){
if("*".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("/".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("+".equals(peek) && ("+".equals(cur) || "-".equals(cur))){
return true;
}else if("-".equals(peek) && ("+".equals(cur) || "-".equals(cur))){
return true;
}
return false;
}

public static void main(String[] args) {
Calculate calculate = new Calculate();
String s = "12+(23*3-56+7)*(2+90)/2";
ArrayList result = calculate.getStringList(s); //String转换为List
result = calculate.getPostOrder(result); //中缀变后缀
int i = calculate.calculate(result); //计算
System.out.println(i);

}

}

㈡ java问题，怎么将字符串型的数学表达式计算出结果

这涉及到一个技术：【表达式分析】

可以利用到栈数据结构来分析，也可以硬来，按人脑怎么算，你就怎么算。

如果你只是想解决这个问题，其中一个简单的思路是：

你要解决的问题实际是算出这样格式的字符串表达式的结果：
<number><op><number><op><number><op><number>...

<number>表示任意数.比如41,55,66234,-244

<op>表示任意运算符,比如+,-,*,/,%,^

把<op>按优先级排列。

先算完优先级高的，再算优先级低的。“5+2*3*1”的具体步骤是：

先算优先级高的2*3=6

用6替换掉2*3,

得到 "5+6*1"

再检测是否还有高优先级的*,有则
6*1=6,用"6"替换掉"6*1"

得到"5+6"

接着没有高优先级的运算符字符了，可以算低优先级字符
接着得到用"11"替换"5+6"。

如果你还需要其他更为精妙和复杂的方法，建议你分别搜索关键字：

“栈 表达式求值”
“编译原理 表达式求值”
“树 表达式求值”

因为表达式分析是一门复杂的技术，不仅仅是四则运算，还包括所有语言分析（包括伪自然语言分析）

㈢ JAVA中如何计算字符串表达式的结果，如："2+8/2*6-12"。高手们过来看看。

在回答你的问题之前 做两个说明！
1. 你的输入要合法(不含字母，运算符后有且必须有数字,中间不能有空格）
import java.util.*;
import java.util.regex.*;
import java.lang.*;
public class CountExpression{
static String[] operater =new String[20];
static String[] number = new String[20];
public int countExpression(String str){

Stack countStack1 = new Stack();
Stack countStack2 = new Stack();
int result =0;
number = str.split("\\/|\\*|\\+|\\-");
operater= str.split("\\d+");
for(int i = 0; i<number.length;i++){
countStack1.push(number[i]);
if(i!=number.length-1){
countStack1.push(operater[i+1]);

}
}
while(!countStack1.isEmpty())
countStack2.push(countStack1.pop());
String op;
while(!countStack2.isEmpty()){
result=0;
op = countStack2.pop().toString();
if(op.equals("*")){
result=Integer.parseInt(countStack1.pop().toString())*Integer.parseInt(countStack2.pop().toString());
countStack1.push(result);

continue;
}
if(op.equals("/")){
result=Integer.parseInt(countStack1.pop().toString())/Integer.parseInt(countStack2.pop().toString());
countStack1.push(result);
continue;
}
countStack1.push(op);

}
while(!countStack1.isEmpty())
countStack2.push(countStack1.pop());

while(!countStack2.isEmpty()){
result=0;
op = countStack2.pop().toString();
if(op.equals("+")){
result=Integer.parseInt(countStack1.pop().toString())+Integer.parseInt(countStack2.pop().toString());
countStack1.push(result);
continue;
}
if(op.equals("-")){
result=Integer.parseInt(countStack1.pop().toString())-Integer.parseInt(countStack2.pop().toString());
countStack1.push(result);
continue;
}
countStack1.push(op);

}
return result;
//System.out.println(result);

}
public static void main(String[] args){
int num;
CountExpression ct= new CountExpression();
num = ct.countExpression("222+2*6*7-112*2+5*2-6*7");
System.out.println(num);
}

}
交给你个任务！ 输入检查：像 2+/2*5+5-6, 2a+2/4+7 2*4-7/ 能提示输入错误
如果中间有空册删除
（提示用正则）
另外增加对括号的处理像 ： 2*(2+3)/2

㈣ java 怎么 字符串进行运算 如：String str = "(((12 -2) * 5 ) /2) +30"; 最好要有代码。

如果你说的是用一个counter(String
str)的方法调用后得到str的计算结果话
2个数字加一个运算符，3个一组进行计算，得到一个数字，加另一个数字和运算符继续计算
需要注意string中连续的数字要整合成一个数字
加上括号的时候运算顺序要小心，特别注意括号前有计算数字，比如5+（2+5）
括号后面有乘除法运算，比如5+（2+5）/2
括号算完了要继续算后面的除法，之后用得到的数字加上前面的加号运算符和‘5’一起运算，算法思想就是这样了
要是有堆栈就建俩堆栈，一个运算符，一个数字
没括号的：数字压栈，符号压栈，数字压栈，判断下一个符号是否为乘除号，不是数字退栈，符号退栈，数字退栈，计算，得到结果，数字压栈，是乘除号，继续符号压栈，数字压栈，数字退栈，符号退栈，数字退栈，计算，数字压栈，数字退栈，符号退栈，数字退栈，计算，数字压栈
要是有括号：遇到括号后，正括号压栈，数字压栈，符号压栈，数字压栈，数字退栈，符号退栈，数字退栈，计算，得到结果……（与不加括号的情况一样）……直到遇到反括号，将正括号退栈，先看后面是否有乘除符号，若没有，看看符号栈是否为空，若不为空说明是括号前有运算的情况，将整个括号得到的数值当做数字压栈后按不带括号的处理，后面有乘除法，先乘除然后作为一个数字继续运算
用数组就建立2个数组，2个int型变量作为数组指针，一个存符号，一个存数字，方法与用堆栈相同
代码量一般，0分完全没有写代码的欲望啊，不过我的算法是正确的，望采纳

㈤ Java计算字符串中的数学表达式的值算法怎么写

代码网上很多，只说说算法吧
12+8/4-5+(3-4)

把这样的表达式拆成：(操作数)(操作符) 、
12+
8/
4-
5+(
3-
4)
(术语叫做逆波兰式)
默认的计算顺序是从左往右，记为left。另设从右往左，记为right
设计Element类，具有 操作数 operant, 操作符operator, 操作顺序 order三个属性
用两个先进后出的栈结构Stack<Element> a,b;
一开始所有的Element都在a中，逐个弹出计算合并值，
当遇到乘、除、括号时计算顺序改变成right，把当前结果放到b中暂存。
直到再次遇到加、减、)右括号时，意味计算顺序复位成left，先把b中的暂存结果全部合并后，再继续算a中的剩余数据
最后合并成一个结果值。

㈥ 谈谈JAVA如何计算字符串公式

可以使用 commons-jexl3 jar包
示例:

public static void main(String[] args){ String expressionString = "1+2+3"; JexlEngine jexlEngine = new JexlBuilder().create(); JexlExpression jexlExpression = jexlEngine.createExpression(expressionString); Object evaluate = jexlExpression.evaluate(null); System.out.println(evaluate); }

结果: 6
示例2:
来个复杂点的

public static void main(String[] args){ // String expressionString = "1+2+3"; String expressionString = "100*10-(200+300)"; JexlEngine jexlEngine = new JexlBuilder().create(); JexlExpression jexlExpression = jexlEngine.createExpression(expressionString); Object evaluate = jexlExpression.evaluate(null); System.out.println(evaluate); }

结果: 500

㈦ java中 怎么将一个字符串型的算式算出结果 必须要方法易懂，方法别太高级，初学

字符串的算式 我给你说些方法和思路吧 要算 其实就是 拆分他 然后将数字部分转化 然后进行计算
第一步 例如 indexOf("+")找符号 然后String[] arr=split("+") 拆分 然后将两部分运算 arr[0] arr[1]
当然了 这是简单的 或者用 substring(起始位置,终止位置) 截取两个来算也行

㈧ Java，字符串类型的计算式直接计算

可以直接用BigDecimal

2.45 和 25 都是以字符串保存的，而且计算的结果也是字符串形式保存

不用考虑基本数据类型之间的转换

㈨ java字符串长度计算

val=val.substring(0, val.length()-1);

就和数组一样，下标是从0开始的，这个没办法，必须要适应，必须习惯，想我现在已经习惯了。非编程上，我都喜欢用0做开始。

上面的数字如果你看着迷糊，用字母代替：
“abcdef”.substring(0,5) 的结果还是abcdef