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