Ⅰ java編程數學表達式的計算！

採用棧的形式存取數據，根據二叉樹，進行數學運算。你要是學了數據結構就明白怎麼做了……

Ⅱ JAVA表達式計算

1）3.5
2）12.5

望滿意~

Ⅲ java三元表達式怎麼算

舉個簡單例子吧抄。

int a=1;int b=2;int c= a>b?1:0，結果襲c 為0。a>b 為條件，後面當條件為true時返回":"前面的結果，反之返回":"後面的結果。

Ⅳ 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計算數學表達式的程序

清單 1. Function、Operator 和 Variable 類的定義
public class Function
{
public String function;
public int number_of_arguments;
public Function( String function, int number_of_arguments )
{
this.function=function;
this.number_of_arguments=number_of_arguments;
}
public String toString()
{
return function;
}
}
public class Operator
{
public String operator;
public byte priority;
public Operator( String operator, byte priority )
{
this.operator=operator;
this.priority=priority;
}
public String toString()
{
return operator;
}
}
public class Variable
{
public String variable;
public double value;
public Variable( String variable, double value )
{
this.variable=variable;
this.value=value;
}
public String toString()
{
return variable;
}
}

Token 類如清單 2 所示。

清單 2. Token 類
public class Token
{
public Object token;
public char mark;
public int position;
public int length;
public Token ( Object token, char mark, int position, int length )
{
this.token=token;
this.mark=mark;
this.position=position;
this.length=length;
}
public String toString()
{
return token.toString()+" ; "+mark+" ; "+position+" ; "+length+"
";
}
}

清單 3. 三種括弧
import java.util.Stack;
public class Parentheses_check
{
public static boolean is_open_parenthesis( char c )
{
if ( c=='(' || c=='[' || c=='{' )
return true;
else
return false;
}
public static boolean is_closed_parenthesis( char c )
{
if ( c==')' || c==']' || c=='}' )
return true;
else
return false;
}
private static boolean parentheses_match( char open, char closed )
{
if ( open=='(' && closed==')' )
return true;
else if ( open=='[' && closed==']' )
return true;
else if ( open=='{' && closed=='}' )
return true;
else
return false;
}
public static boolean parentheses_valid( String exp )
{
Stack s = new Stack();
int i;
char current_char;
Character c;
char c1;
boolean ret=true;
for ( i=0; i < exp.length(); i++ )
{
current_char=exp.charAt( i );
if ( is_open_parenthesis( current_char ) )
{
c=new Character( current_char );
s.push( c );
}
else if ( is_closed_parenthesis( current_char ) )
{
if ( s.isEmpty() )
{
ret=false;
break;
}
else
{
c=(Character)s.pop();
c1=c.charValue();
if ( !parentheses_match( c1, current_char ) )
{
ret=false;
break;
}
}
}
}
if ( !s.isEmpty() )
ret=false;
return ret;
}
}
清單 4. 正確的表達式開頭的檢查
private static boolean begin_check( Vector tokens, Range r, StringBuffer err )
{
char mark;
Token t;
t=(Token)tokens.elementAt( 0 );
mark=t.mark;
if ( mark=='P' )
err.append( Messages.begin_operator );
else if ( mark==')' )
err.append( Messages.begin_parenthesis );
else if ( mark=='Z' )
err.append ( Messages.begin_comma );
else
return true;
r.start=0;
r.end=t.length;
return false;
}
清單 5. 找出第一個閉括弧
public static int pos_first_closed_parenthesis( Vector tokens )
{
Token t;
for ( int i=0; i<tokens.size(); i++ )
{
t=(Token)tokens.elementAt( i );
if ( t.mark==')' )
return i;
}
return 0;
}
清單 6. 找出匹配的開括弧
public static int pos_open_parenthesis( Vector tokens, int closed_parenthesis )
{
int i;
Token t;
i=closed_parenthesis-2;
while ( i>=0 )
{
t=(Token)tokens.elementAt( i );
if ( t.mark=='(' )
{
return i;
}
i--;
}
return 0;
}

清單 7. 找出優先順序最高的操作符
public static int pos_operator( Vector tokens, Range r )
{
byte max_priority=Byte.MAX_VALUE;
int max_pos=0;
byte priority;
String operator;
Token t;
for ( int i=r.start+2; i<=r.end-2; i++ )
{
t=(Token)tokens.elementAt( i );
if ( t.mark!='P' )
continue;
priority=((Operator)t.token).priority;
operator=((Operator)t.token).operator;
if ( priority < max_priority || ( operator.equals("^") ||
operator.equals("**") ) && priority == max_priority )
{
max_priority=priority;
max_pos=i;
}
}
return max_pos;
}
清單 8. 檢查是否還有其它操作符
...
int poz_max_op=pos_operator( tokens, range );
// if there are no operators
if ( poz_max_op==0 )
{
if ( no_more_parentheses )
{
return false;
}
else
{
double result;
result=function_result( tokens, range.start-1 );
function_tokens_removal( tokens, range.start-1 );
t = new Token ( new Double(result), 'D', 0, 0 );
tokens.setElementAt( t, range.start-1 );
parentheses_removal( tokens, range.start-1 );
return true;
}
}
...

清單 9. 獲取操作數並執行運算...
double operand1, operand2;
// first operand is before...
t=(Token)tokens.elementAt( poz_max_op-1 );
operand1=operand_value( t );
// ...and second operand is after operator
t=(Token)tokens.elementAt( poz_max_op+1 );
operand2=operand_value( t );
// operator
t=(Token)tokens.elementAt( poz_max_op );
String op=((Operator)t.token).operator;
double result=operation_result( operand1, operand2, op );
tokens.removeElementAt( poz_max_op+1 );
tokens.removeElementAt( poz_max_op );
t = new Token ( new Double(result), 'D', 0, 0 );
tokens.setElementAt( t, poz_max_op-1 );
parentheses_removal( tokens, poz_max_op-1 );
...
清單 10. 獲取操作數
public static double operand_value( Token t )
{
if ( t.mark=='V' )
return ((Variable)t.token).value;
else if ( t.mark=='D' )
return ((Double)t.token).doubleValue();
else if ( t.mark=='H' )
return base_convert( ((String)t.token).substring(2), 16 );
else if ( t.mark=='O' )
return base_convert( ((String)t.token).substring(2), 8 );
else if ( t.mark=='B' )
return base_convert( ((String)t.token).substring(2), 2 );
}
清單 11. 將數轉化為十進制數
public static long base_convert( String s, int base )
{
long r=0;
int i, j;
for ( i=s.length()-1, j=0; i>=0; i--, j++ )
r=r+digit_weight( s.charAt( i ) )*(long)Math.pow( base, j );
return r;
}
public static int digit_weight( char c )
{
if ( Character.isDigit( c ) )
return c-48;
else if ( 'A'<=c && c<='f' )
return c-55;
else if ( 'a'<=c && c<='f' )
return c-87;
return -1;
}
清單 13. 除去冗餘括弧
private static void parentheses_removal( Vector tokens, int pos )
{
if (
pos>1 &&
amp;&&
amp;
((Token)tokens.elementAt( poz-2 )).mark!='F' &&
amp;&&
amp;
((Token)tokens.elementAt( poz-1 )).mark=='(' &&
amp;&&
amp;
((Token)tokens.elementAt( poz+1 )).mark==')'
||
pos==1 &&
amp;&&
amp;
((Token)tokens.elementAt( 0 )).mark=='(' &&
amp;&&
amp;
((Token)tokens.elementAt( 2 )).mark==')'
)
{
tokens.removeElementAt( poz+1 );
tokens.removeElementAt( poz-1 );
}
return;
}

清單 14. 結合符號並顯示結果
public static String token_join( Vector tokens )
{
String result=new String();
Token t;
for ( int i=0; i < tokens.size(); i++ )
{
t=(Token)tokens.elementAt( i );
if ( t.mark=='D' )
{
double n=((Double)t.token).doubleValue();
result=result + formated_number( n );
}
else
result=result + t.token;
if ( result.endsWith( ".0" ) )
result=result.substring( 0, result.length()-2 );
result=result + " ";
}
return result;
}
結論

本文分析了一個 applet ，它能一步一步的對算術表達式求值。同時還按順序回顧了最有意思的代碼片段，並論述了兩種不同的表達式求值方法。

下一版 W3Eval 有望在各方面得到增強，包括有能力添加用戶定義的功能；支持分數、復數和矩陣；改良的圖形用戶界面（GUI）；大小和速度優化以及安全性方面的增強。我鼓勵您提供您自己對於增強方面的設想。

我希望您會發現 W3Eval 是個對表達式求值有益的在線工具，它在某種程度上比經典的方法更簡單自然。我還期待這里談到的代碼和演算法使您明白 Java 語言有助於處理數學問題。

!強烈要求加分！

Ⅵ Java計算表達式。

有個
bashell吧，可以
名字記不清了，回去給你找一下。

Ⅶ JAVA語言計算表達式的結果

沒現成的程序，話說網路的積分沒啥用，沒人願意為20分去給你寫程序的。。
簡單提示下吧
這個是
編譯原理
的內容，兩個簡單的方法
1、
遞推
下降分析器，就是LL分析
2、
算符
優先分析，就是LR分析的簡化版
找代碼的話，去看嚴蔚敏數據結構。。。上面有。。。是基於算符優先的，優先表都給出來了。。。
用LL的話，去找javacc吧，裡面自帶的例子就是你要的。。。

Ⅷ 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中運算表達式

Java表達式是變數、常量、運算符、方法調用的序列，它執行指定的計算並返內回某個確定的容值。

其中，運算符按操作數的數目：有一元運算符（++、--）、二元運算符（+、-、>等等）和三元運算符（？：），它們分別對應一到三個操作數。

表達式一般按運算符來分：

算術表達式（float x=8.3f、i++）、

關系表達式（3>7、3<7）、

布爾邏輯表達式（(5>4)&&true、!false）、

位運算表達式(a=34^3)、

賦值表達式、

條件表達式(b=100>89?a=ture:a=false)

以及復合表達式。

還有一種叫「表達式語句」，就是在表達式後加上分號作為語句來使用。(int i=123;)

Ⅹ 計算表達式的值 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);
}

}