java加減運算

1. 加減乘除運算（java)

實際上這相當於javascript的eval方法，以下是該方法的java實現：

//Eval.java
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Eval {
public int eval(String exp){
List<String> list = infixExpToPostExp(exp);//轉化成後綴表達式
return doEval(list);//真正求值
}

//遇到操作符壓棧，遇到表達式從後綴表達式中彈出兩個數，計算出結果，壓入堆棧
private int doEval(List<String> list) {
Stack<String> stack = new Stack<String>();
String element;
int n1,n2,result;
try{
for(int i = 0; i < list.size();i++){
element = list.get(i);
if(isOperator(element)){
n1 = Integer.parseInt(stack.pop());
n2 = Integer.parseInt(stack.pop());
result = doOperate(n1,n2,element);
stack.push(new Integer(result).toString());
}else{
stack.push(element);
}
}
return Integer.parseInt(stack.pop());
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
}

private int doOperate(int n1, int n2, String operator) {
if(operator.equals("+"))
return n1 + n2;
else if(operator.equals("-"))
return n1 - n2;
else if(operator.equals("*"))
return n1 * n2;
else
return n1 / n2;
}

private boolean isOperator(String str){
return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
}

private List<String> infixExpToPostExp(String exp){//將中綴表達式轉化成為後綴表達式
List<String> postExp = new ArrayList<String>();//存放轉化的後綴表達式的鏈表
StringBuffer numBuffer = new StringBuffer();//用來保存一個數的
Stack<Character> opStack = new Stack<Character>();//操作符棧
char ch,preChar;
opStack.push('#');
try{
for(int i = 0; i < exp.length();){
ch = exp.charAt(i);
switch(ch){
case '+':
case '-':
case '*':
case '/':
preChar = opStack.peek();
// 如果棧裡面的操作符優先順序比當前的大，則把棧中優先順序大的都添加到後綴表達式列表中
while(priority(preChar) >= priority(ch)){
postExp.add(""+preChar);
opStack.pop();
preChar = opStack.peek();
}
opStack.push(ch);
i++;
break;
case '(':
// 左括弧直接壓棧
opStack.push(ch);
i++;
break;
case ')':
// 右括弧則直接把棧中左括弧前面的彈出，並加入後綴表達式鏈表中
char c = opStack.pop();
while(c != '('){
postExp.add("" + c);
c = opStack.pop();
}
i++;
break;
// #號，代表表達式結束，可以直接把操作符棧中剩餘的操作符全部彈出，並加入後綴表達式鏈表中
case '#':
char c1;
while(!opStack.isEmpty()){
c1 = opStack.pop();
if(c1 != '#')
postExp.add("" + c1);
}
i++;
break;
//過濾空白符
case ' ':
case '\t':
i++;
break;
// 數字則湊成一個整數，加入後綴表達式鏈表中
default:
if(Character.isDigit(ch)){
while(Character.isDigit(ch)){
numBuffer.append(ch);
ch = exp.charAt(++i);
}
postExp.add(numBuffer.toString());
numBuffer = new StringBuffer();
}else{
throw new IllegalExpressionException("illegal operator");
}
}
}
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
return postExp;
}

private int priority(char op){//定義優先順序
switch(op){
case'+':
case'-':
return 1;
case'*':
case'/':
return 2;
case'(':
case'#':
return 0;
}
throw new IllegalExpressionException("Illegal operator");
}

}

Main.java 主函數所在類
public class Main
{
public static void main(String[] args) {

try {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String exp=br.readLine();

int result = eval.eval(exp);
System.out.println(result);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

IllegalExpressionException異常類
public class IllegalExpressionException extends RuntimeException{

public IllegalExpressionException(){

}

public IllegalExpressionException(String info){
super(info);
}
}

2. JAVA中實現計算加法的功能

你需要看一下swing事件的編寫，你需要調用文本框的getText方法得到裡面的數值，然後為「=」按鈕寫監聽事件，調用第三個文本框的setText方法顯示結果。我這里有個跟你界面相同的完善版，包括加減乘除運算的，我在代碼中用加粗著重突出了事件的那部分。import javax.swing.*;
import java.awt.*;
import java.awt.event.*;public class AA extends JFrame
{
protected JTextField tFirst,tSecond,tResult,tEqual;
private JComboBox cFu;
private JButton jOk;
private String sFuHao;
protected String sFirst;

float fFirst,fSecond,fResult;

private String cFuHao[] = {
"+","-","*","/"
};

public AA()
{
super( "Calculator" );

Container container = getContentPane();
container.setLayout( new FlowLayout() );
tFirst = new JTextField( 10 );
container.add( tFirst );
cFu = new JComboBox( cFuHao );
cFu.setMaximumRowCount( 3 );
container.add( cFu );
tSecond = new JTextField( 10 );
container.add( tSecond );

tEqual = new JTextField( "=", 1 );
tEqual.setEditable( false );
container.add( tEqual );

tResult = new JTextField( 10 );
tResult.setEditable( false );
container.add( tResult );

jOk = new JButton( "calculate" );
container.add( jOk );

ButtonHandler handler = new ButtonHandler();
jOk.addActionListener( handler );
setSize( 600,80 );
setVisible( true );

}

public static void main( String args[] )
{
AA application = new AA();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

private class ButtonHandler implements ActionListener{

public void actionPerformed( ActionEvent event )
{
sFuHao=(String)cFu.getSelectedItem();
if((tFirst.getText()).equals("#")||(tSecond.getText()).equals("#"))
System.exit(0);

fFirst = Float.parseFloat(tFirst.getText());
fSecond = Float.parseFloat(tSecond.getText());

if(sFuHao.equals("+"))
fResult = fFirst + fSecond;
else if(sFuHao.equals("-"))
fResult = fFirst - fSecond;
else if(sFuHao.equals("*"))
fResult = fFirst * fSecond;
else
fResult = fFirst / fSecond;

tResult.setText( String.valueOf(fResult) );
}
}
}

3. 如何使用java實現加減乘除運算

java有內置的運算符
+ - * /
int a=1,b=2;
a+b;
a-b;
a*b;
a/b;

4. java int double 加減法 基本類型運算問題

1.-2.8421709430404007E-14表示-2.8421709430404007乘以10的-14次方，計算機能准確表示十進制的整數，但不能准確表示十進制小數。System.out.println(150.0+0+183.28-0-183.28-150.0);150.0+0+183.28-0-183.28-150.0的結果為0.00000000000...，只不過你的輸出結果為double型，精度比較高，沒有超出列印函數（println之類的）的默認精度而已。

2.System.out.println(((150.00)+0.00+(183.28))-(0.00+(183.28)+(150.00)));中將((150.00)+0.00+(183.28))作為個運算單元，二個括弧內的運算的結果肯定一樣，與精度無關。結果當然為0。

3.用System.out.println((long)(150.0+0+183.28-0-183.28-150.0));(150.0+0+183.28-0-183.28-150.0)的結果為0.00000000...,轉換成long，舍棄小數位，結果自然為0；

4.System.out.println(150.0F+0+183.28F-0-183.28F-150.0F); 運算結果為float型，超出列印函數（println之類的）的默認精度，截取下來為0。

不知道解釋的你滿意不？

5. 【高分懸賞】Java實現一個方法計算一個只有加減法運算的表達式的值

這個問題很簡單，只有加減運算，沒有運算優先順序，不需要用到堆棧就可以。下面是代碼：

publicclassApp{

	publicstaticintA(Stringex)throwsException{
		
		intresult=0;
		
		Stringstr="";
		
		for(inti=0;i<ex.length();i++){
			
			charch=ex.charAt(i);
			
			if(ch>='0'&&ch<='9'){
				
				str+=ch;
				
			}elseif(ch=='+'||ch=='-'){
				
				result+=Integer.parseInt(str);
				str=""+ch;
				
			}elseif(ch==''){
				continue;
			}else{
				thrownewException("無效的表達式。");
			}
		}
		
		if(str!=""){
			result+=Integer.parseInt(str);
		}
		
		returnresult;
	}
	
	publicstaticvoidmain(String[]args)throwsException{
		
		intresult=A("1-2+3+4-23");
		
		System.out.println("result="+result);
	}
}

運行結果：

6. 用JAVA接受用戶輸入兩個數字，進行加減運算

那要看你是用什麼IDE來編程的啦，運行java程序要必須首先安裝JDK。
1.如果你是用記事本編輯的話。「運行」--「notepad」
輸入：
public class Add
{
public static void main(String args[])
{
int a;
int b;
int result;
a=Integer.parseInt(args[0]);
b=Integer.parseInt(args[1]);
result=a+b;
System.out.println(result);
}
}
保存為「Add.java」
「運行」-「CMD」-進入剛才保存的目錄
使用「javac（空格）Add.java」編譯成class文件
使用「java（空格）Add（空格）2（空格）1」運行
結果：3
還記得public static void main(String[] args)嗎？這里的args就是你的啟動參數。

在運行時你輸入java package1.class1 -arg1 -arg2，args中就會有兩個String，一個是arg1，另一個是arg2。
2.如果你是用eclipse3.1.2的話。麻煩點，因為它自帶控制台。所以代碼在運行時要進行設置：
同樣是上面的代碼
在eclipse3.1.2中，右擊類名「Add.java」在彈出菜單中選擇「run as」--「run……」--彈出對話框--在「java application」中，你會看到剛創建的「Add.java」如果沒有在左下方，點擊「new」--在右面的「(x)=arguments」選項卡中的「program arguments」中輸入「1（空格）2」--「apply」--「run」
在下面的「console」即可看到「3」

7. java的加減乘除運算

使用BigDecimal並且一定要用String來夠造。
實現方法如下：

import java.math.BigDecimal;

/**

* 由於Java的簡單類型不能夠精確的對浮點數進行運算，這個工具類提供精

* 確的浮點數運算，包括加減乘除和四捨五入。

*/

public class Arith{

//默認除法運算精度

private static final int DEF_DIV_SCALE = 10;

//這個類不能實例化

private Arith(){

}

/**

* 提供精確的加法運算。

* @param v1 被加數

* @param v2 加數

* @return 兩個參數的和

*/

public static double add(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.add(b2).doubleValue();

}

/**

* 提供精確的減法運算。

* @param v1 被減數

* @param v2 減數

* @return 兩個參數的差

*/

public static double sub(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.subtract(b2).doubleValue();

}

/**

* 提供精確的乘法運算。

* @param v1 被乘數

* @param v2 乘數

* @return 兩個參數的積

*/

public static double mul(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.multiply(b2).doubleValue();

}

/**

* 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到

* 小數點以後10位，以後的數字四捨五入。

* @param v1 被除數

* @param v2 除數

* @return 兩個參數的商

*/

public static double div(double v1,double v2){

return div(v1,v2,DEF_DIV_SCALE);

}

/**

* 提供（相對）精確的除法運算。當發生除不盡的情況時，由scale參數指

* 定精度，以後的數字四捨五入。

* @param v1 被除數

* @param v2 除數

* @param scale 表示表示需要精確到小數點以後幾位。

* @return 兩個參數的商

*/

public static double div(double v1,double v2,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

* 提供精確的小數位四捨五入處理。

* @param v 需要四捨五入的數字

* @param scale 小數點後保留幾位

* @return 四捨五入後的結果

*/

public static double round(double v,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

};

8. java初學減法運算

在大多數情況下，使用double和float計算的結果是准確的，但是在一些精度要求很高的系統中，這種問題是非常嚴重的。

在《EffectiveJava》中提到一個原則，那就是float和double只能用來作科學計算或者是工程計算，但在商業計算中我們要用java.math.BigDecimal，通過使用BigDecimal類我們可以解決上述問題，實例代碼如下：

packageex;

importjava.math.*;

publicclassBigDecimalDemo{
publicstaticvoidmain(String[]args){
System.out.println(ArithUtil.add(0.01,0.05));
System.out.println(ArithUtil.sub(1.0,0.42));
System.out.println(ArithUtil.mul(4.015,100));
System.out.println(ArithUtil.div(123.3,100));
}
}

classArithUtil{
privatestaticfinalintDEF_DIV_SCALE=10;

privateArithUtil(){}

publicstaticdoubleadd(doubled1,doubled2){
BigDecimalb1=newBigDecimal(Double.toString(d1));
BigDecimalb2=newBigDecimal(Double.toString(d2));
returnb1.add(b2).doubleValue();

}

publicstaticdoublesub(doubled1,doubled2){
BigDecimalb1=newBigDecimal(Double.toString(d1));
BigDecimalb2=newBigDecimal(Double.toString(d2));
returnb1.subtract(b2).doubleValue();

}

publicstaticdoublemul(doubled1,doubled2){
BigDecimalb1=newBigDecimal(Double.toString(d1));
BigDecimalb2=newBigDecimal(Double.toString(d2));
returnb1.multiply(b2).doubleValue();

}

publicstaticdoublediv(doubled1,doubled2){

returndiv(d1,d2,DEF_DIV_SCALE);

}

publicstaticdoublediv(doubled1,doubled2,intscale){
if(scale<0){
("");
}
BigDecimalb1=newBigDecimal(Double.toString(d1));
BigDecimalb2=newBigDecimal(Double.toString(d2));
returnb1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

}

9. java中如何實現字元與數字加減運算

int f = 'a' + 4;
System.out.println(f);
結果是：來101
System.out.println((char)f);
結果是：e
java中也是源可以字元+數值的，java也是會自動類型轉換的（由低到高，成為隱式轉換），相加過程中會將char型先轉int型然後相加。 如果由高到低類型的轉換就得強轉（稱為顯式轉換），如:(char)101

10. java 編寫一個可對復數進行加減運算的程序

1、real和image這兩復個field前面的static去掉。制

2、public Complex() 這個構造器去掉，如果要接受輸入的話，應該放到main方法里，這樣這個類更清晰。

3、靜態方法Complex_add和Complex_minus沒指定返回值類型，應該返回的是Complex。另外方法名字首字母應小寫。

4、參考這個：http://..com/question/151336863.html