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中的剩餘數據
最後合並成一個結果值。
2. java 計算表達式的值
乘法運算時，這個表達式1/(n+1))的值為0，後面乘多少都是0
System.out.println(1/(n+1))
3. 表達式求值 數據結構 java實現
1. 定義優先順序和優先順序表
Java代碼
/**
* 運算符優先權
*/
public enum Precede {
/**
* 優先權高
*/
LARGER,
/**
* 優先權低
*/
LESS;
/**
* 優先順序表
* + - * /
* + > > < <
* - > > < <
* * > > > >
* / > > > >
*/
private static Precede[][] precedes = new Precede[4][4];
static {
// 根據優先順序表初始化precedes數組
for (int i = 0; i < precedes.length; i++) {
for (int j = 0; j < precedes[i].length; j++) {
if ((i == 0 || i == 1) && j > 1) {
precedes[i][j] = LESS;
} else {
precedes[i][j] = LARGER;
}
}
}
}
/**
* 判斷2個運算符的優先順序
*/
public static Precede judgePrecede(char operand1, char operand2) {
int left = getIndex(operand1);
int right = getIndex(operand2);
return precedes[left][right];
}
/**
* 獲取運算符對應的數組索引
*/
private static int getIndex(char operand) {
switch (operand) {
case '+':
return 0;
case '-':
return 1;
case '*':
return 2;
case '/':
return 3;
default:
throw new IllegalArgumentException();
}
}
}
2. 表達式求值
Java代碼
/**
* 整數表達式運算
*/
public class EvaluateExpression {
/**
* 表達式
*/
private String expression;
/**
* 最初的表達式
*/
private String initExpression;
/**
* 運算符棧
*/
private MyStack<Character> optr = new MyArrayStack<Character>();
/**
* 操作數棧
*/
private MyStack<Integer> opnd = new MyArrayStack<Integer>();
/**
* 表明下一個是否應該是數字
*/
private boolean numberNext;
public EvaluateExpression(String expression) {
this.expression = expression;
this.initExpression = expression;
numberNext = true;
}
/**
* 求值
*/
public Integer evaluate() {
delBlank();
handleParentheses();
while (true) {
if ("".equals(expression)) {
break;
}
if (expression.matches("^-?\\d+.*$") && numberNext) {
opnd.push(getInteger());
continue;
} else {
Character operand = expression.charAt(0);
numberNext = true;
expression = expression.substring(1);
Character pop = optr.pop();
if (pop == null) {
optr.push(operand);
continue;
} else {
Precede precede = Precede.judgePrecede(pop, operand);
switch (precede) {
// 優先順序高時運算前2個操作數
case LARGER: {
optr.push(operand);
Integer next = opnd.pop();
Integer last = opnd.pop();
evaluateNow(last, pop, next);
break;
}
// 優先順序低時運算前一個操作數和後一個操作數
case LESS: {
optr.push(pop);
Integer last = opnd.pop();
Integer next = getInteger();
evaluateNow(last, operand, next);
break;
}
}
}
}
}
// 運算結果
Integer result = null;
if (optr.length() == 0 && opnd.length() == 1) {
result = opnd.pop();
} else if (optr.length() == 1 && opnd.length() == 2) {
Integer next = opnd.pop();
Integer last = opnd.pop();
evaluateNow(last, optr.pop(), next);
result = opnd.pop();
} else {
throw new RuntimeException();
}
return result;
}
/**
* 進行實際的運算，並將結果入棧
*/
private void evaluateNow(Integer last, Character operand, Integer next) {
switch (operand) {
case '+':
opnd.push(last + next);
break;
case '-':
opnd.push(last - next);
break;
case '*':
opnd.push(last * next);
break;
case '/':
opnd.push(last / next);
break;
}
}
/**
* 獲得表達式開頭部分的整數
*/
private Integer getInteger() {
StringBuilder sb = new StringBuilder();
int count = 0; // 整數位
boolean lessZero = false; // 是否是負數
if (expression.startsWith("-")) {
sb.append("-");
count++;
lessZero = true;
}
int i = (lessZero ? 1 : 0);
for (; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c >= '0' && c <= '9') {
sb.append(c);
count++;
} else {
break;
}
}
expression = expression.substring(count);
numberNext = false;
return Integer.valueOf(sb.toString());
}
/**
* 處理括弧. 將括弧內的字元串作為子表達式計算.
*/
private void handleParentheses() {
while (expression.contains("(")) {
// 左括弧的索引
int left = 0;
// 右括弧的索引
int right = 0;
// 左括弧的數量
int count = 0;
// 求出左括弧索引
left = expression.indexOf('(');
// 求出對應的右括弧索引
for (int i = left; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == ')') {
count--;
// count為0時才是對應的右括弧
if (count == 0) {
right = i;
break;
}
} else if (c == '(') {
count++;
} else {
continue;
}
}
// 左右括弧之間是一個子表達式, 計運算元表達式的值，並根據結果構造出新的表達式
EvaluateExpression evaluateExpression = new EvaluateExpression(expression.substring(left + 1, right));
expression = expression.substring(0, left) + evaluateExpression.evaluate()
+ expression.substring(right + 1);
}
}
/**
* 刪除表達式中的空白字元
*/
private void delBlank() {
expression = expression.replaceAll("\\s", "");
}
@Override
public String toString() {
return initExpression;
}
}
3. 進行測試
Java代碼
@Test
public void testEvaluate() {
EvaluateExpression expression = new EvaluateExpression("1 + 2 ");
System.out.println(expression + " = " + expression.evaluate());
expression = new EvaluateExpression("4 + 2 * 3 - 10 / 5");
System.out.println(expression + " = " + expression.evaluate());
expression = new EvaluateExpression("(1+2) * (4 + 5) - (9 / 7)");
System.out.println(expression + " = " + expression.evaluate());
expression = new EvaluateExpression("(1 + (3 * (4 - 9)))");
System.out.println(expression + " = " + expression.evaluate());
expression = new EvaluateExpression("(1 + (3 * (4 - 9))) + (3 * (2 + 3))");
System.out.println(expression + " = " + expression.evaluate());
}
測試的結果為:
1 + 2 = 3
4 + 2 * 3 - 10 / 5 = 8
(1+2) * (4 + 5) - (9 / 7) = 26
(1 + (3 * (4 - 9))) = -14
(1 + (3 * (4 - 9))) + (3 * (2 + 3)) = 1
4. Java的算術運算 a,b為int變數，且a=5,b=10.則表達式（a++）+（++b）+a*b的值為多少啊
你好，很高興為你解答。
表達式的值為82。
a++的值為5，因為++放在後面，表達式的值等於a,但a的值變成了6
++b的值為11，因為++方在前面，表達式的值等於b+1，b的值也變成了11
(a++)為5，(++b)為11
a*b
為6*11，最後加起來為82。
5. Java 中可以輸出表達式的值嗎 如i+5*j
inti=1,j=2;
System.out.println(i+5*j);//11
java中，表達式是一種運算，運算結果是一個確定的值。只要你使用這個表達式得到一個結果值，那就可以用。
6. 計算表達式的值 java
應該是精度問題。所以結果始終是 0
應該是零點幾幾幾
import java.util.Scanner;
/**
cn = [1 / (n+1)] * (2n)! / [(n!) * (n!)]
*/
public class BaiDuTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
double val = 1;
double val2 = 1;
double cn = 1;
val = getFactorial(n);
val2 = getFactorial(2 * n);
cn = (1/(n + 1))*val2/(val*val) ;
System.out.println(n);
System.out.println(cn);
System.out.println(val);
System.out.println(val2);
}
public static double getFactorial(int n) {
double result = 1;
if(n == 1) {
return 1;
}
return result = n * getFactorial(n - 1);
}
}
7. java:算出下列表達式的值
(1)表達式錯誤"="
(2)-32
(3)false
(4)true
(5)2
(6)(y!=(++x))?x:y == 6
8. Java表達式的值及數據類型
System.out.println(1+4/5+(int)5.2/2.5);
4/5為整數除法，結果為0。(int)5.2/2.5是先將5.2轉換為整型得5，再除以2.5，得2.0（注意結果為浮點數），所以最後結果是浮點數，3.0
System.out.println(1+4/5+(int)(5.2/2.5));
由於5.2/2.5加了括弧，所以是先做浮點除法，再轉換為整型，最後結果也是整型，得3
System.out.println(1+4/5+5.2/2.5);
1+0+2.08=3.08，沒什麼好說的
System.out.println(1.0+4/5+5.2/2.5);
1.0是浮點數，4/5先按整數除法來，在轉換為浮點數（得0.0），5.2/2.5=2.08，結果是浮點數3.08
System.out.println(1+4/5.0+5.2/2.5);
由於4/5.0中的除數是浮點數，所以這一步按浮點數除法來計算，得0.8，結果為3.88
9. java表達式是什麼
Java是面向表達式的語言，Java中一個簡單表達式可以是下面任意一種：● 常量：7、false。● 單引號括起來的字元字面常量：'A'、'3'。● 雙引號括起來的字元串字面常量："foo"、"Java"。● 任何正確聲明的變數名：myString、x。● 任何用Java二元運算符（本章稍後將詳細討論）連接起來的兩個上述類型的表達式：x+2。● 任何用Java一元運算符（本章稍後將詳細討論）修飾的單個上述類型的表達式：i++。● 任何用小括弧括起來的上述類型的表達式：(x+2)。以及另外一些與本書後面將要學到的對象有關的表達式類型。無論多麼復雜的表達式都可以由不同類型的簡單表達式和括弧嵌套組合而成，例如：((((4/x) + y) * 7) + z)。2.9.1 算術運算符 Java語言提供了許多基本的算術運算符，如表2-1所示。表2-1 Java算術運算符運算符描 述+加法-減法*乘法/除法%求余（%左邊的操作數除以右邊的
操作數所得到的余數，例如10%3=1）+和-運算符也可作為一元運算符用於表示正負數：-3.7、+42。除了簡單賦值運算符=，還有許多特定的復合賦值運算符，這些運算符將變數賦值和算術操作合並在一起，如表2-2所示。表2-2 Java復合賦值運算符運算符描 述+=a+=b等價於a=a+b-=a-=b等價於a=a-b*=a*=b等價於a=a*b/=a/=b等價於a=a/b%=a%=b等價於a=a%b最後要介紹的兩個算術運算符是一元遞增運算符（++）和一元遞減運算符（--），用於將整數變數的值加1或減1，或者將浮點數變數的值加1.0或減1.0。稱它們為一元運算符是因為它們用於單個變數，而前面討論的二元運算符則連接兩個表達式的值。一元遞增運算符和一元遞減運算符也可用於將字元變數在Unicode序列中向前或向後移動一個字元位置。例如，在下面的代碼片段中，字元變數c的值從'e'遞增為'f'：遞增和遞減運算符可以以前綴或者後綴方式使用。如果運算符放在操作數之前（前綴模式），變數的遞增或遞減操作將在更新後的變數值被用於任何由它構成的賦值操作之前執行。例如，考慮下面的使用前綴遞增運算符的代碼片段，假設a和b在程序前面已經聲明為int變數：上述代碼執行後，變數a的值是2，變數b的值也是2。這是因為在第二行中變數a的遞增（從1到2）發生在它的值賦給b之前。因此這行代碼在邏輯上等價於下面兩行代碼： 另一方面，如果運算符放在操作數之後（後綴模式），遞增或遞減操作發生在原來的變數值被用於任何由它構成的賦值操作之後。看一下以後綴方式使用遞增運算符的相同代碼片段：上述代碼執行後，變數b的值是1，而變數a的值是2。這是因為在第二行中變數a的遞增（從1到2）發生在它的值賦給b之後。因此這行代碼在邏輯上等價於下面兩行代碼：下面是一個稍微復雜一點例子，請閱讀附加的注釋以確保你能夠明白x最終是如何被賦值為10的：稍後將會看到，遞增和遞減運算符通常和循環一起使用。2.9.2 關系和邏輯運算符邏輯表達式以指定的方式比較兩個（簡單或者復雜）表達式exp1和exp2，決議出一個boolean值true或者false。 Java提供了表2-3所示的關系運算符來創建邏輯表達式。表2-3 Java關系運算符運算符描 述exp1==exp2如果exp1等於exp2，值為true（注意使用雙等號測試相等性）exp1>exp2如果exp1大於exp2，值為trueexp1>=exp2如果exp1大於等於exp2，值為trueexp1<exp2如果exp1小於exp2，值為trueexp1<=exp2如果exp1小於等於exp2，值為trueexp1!=exp2如果exp1不等於exp2，值為true!exp如果exp為false值為true，如果exp為true值為false除了關系運算符，Java還提供了用於組合/修飾邏輯表達式的邏輯運算符。表2-4列出了最常用的邏輯運算符。表2-4 Java邏輯運算符運算符描 述exp1&&exp2邏輯「與」，僅當exp1和exp2都為true時復合表達式值為trueexp1||exp2邏輯「或」，exp1或exp2值為true時復合表達式值為true!exp邏輯「非」，將邏輯表達式的值從true切換到false，反之亦然下面這個例子用邏輯「與」運算符來編程實現邏輯表達式「如果x大於2.0且y不等於4.0」：邏輯表達式常用於流程式控制制結構，本章稍後將進行討論。2.9.3 表達式求值和運算符優先順序如同本章前面提到的那樣，任何復雜的表達式都可以用分層嵌套的小括弧構成，例如(((8 * (y + z)) + y) x)。編譯器通常按照從內到外，從左到右的順序對這樣的表達式求值。假設x、y、z按照下面的方式聲明並初始化：下面的賦值語句右邊的表達式：將像下面這樣逐步求值：沒有小括弧時，根據運算符用於表達式求值的順序，某些運算符具有高於其他運算符的優先順序。例如，乘除法先於加減法執行。通過使用小括弧可以強制改變運算符的優先順序，括弧內的運算符比括弧外的先執行。考慮下面的代碼片段：代碼的第一行沒有使用括弧，乘法操作比加法操作先執行，因此整個表達式的值為2+12=14，就像我們將表達式明確地寫成2+(3*4)一樣，當然這樣做沒有必要。 在代碼的第二行，括弧被明確地放在操作2+3兩邊，因此加法操作將首先執行，然後求和結果乘以4作為整個表達式的值，即5*4=20。回到前面的例子注意到>和!=運算符優先順序高於&&運算符，因此可以去掉嵌套的括弧而變成下面這樣：然而，額外的括弧並不會對代碼造成傷害，事實上它可以使表達式的目的更加清楚。2.9.4 表達式類型表達式類型是表達式最終求值結果的Java類型。例如給定下面的代碼片段：表達式(x > 2.0) && (y != 4.0)求值結果為true，因此表達式(x > 2.0) && (y != 4.0)稱為boolean型表達式。在下面的代碼片段中：表達式((8 * (y + z)) + y) * x求值結果為42，因此表達式((8 * (y + z)) + y) * x稱為整型表達式。