導航:首頁 > 編程語言 > java計算字元串公式計算

java計算字元串公式計算

發布時間:2022-10-08 14:04:12

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

閱讀全文

與java計算字元串公式計算相關的資料

熱點內容
少女心貼圖app哪個好 瀏覽:528
企業員工系統源碼 瀏覽:755
java第三方jar 瀏覽:274
安卓為什麼不能掛外服下游戲 瀏覽:249
怎麼能把我的世界伺服器弄卡 瀏覽:332
php網站技術架構圖 瀏覽:601
java對象內存大小 瀏覽:514
stm8s單片機選型 瀏覽:46
pda在app里是什麼意思 瀏覽:374
廣州市的加密軟體公司 瀏覽:662
住賓館有什麼app 瀏覽:305
伺服器工作站中端有什麼異同 瀏覽:213
linux命令的語法 瀏覽:737
mc夢想之國伺服器地址 瀏覽:843
mac開機啟動命令 瀏覽:229
jspoa源碼下載 瀏覽:608
簡單自動化命令 瀏覽:895
linux攝像頭驅動視頻 瀏覽:484
怎麼獲取別人網站源碼 瀏覽:832
安卓版zip文件解壓破解密碼 瀏覽:946