java加減乘除,java加減乘除優先順序

本文目錄一覽：

• 1、加減乘除運算（Java)
• 2、Java的加減乘除問題
• 3、怎麼用java編程，實現分數的加減乘除運算？
• 4、java的加減乘除運算

加減乘除運算（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){

ListString list = infixExpToPostExp(exp);//轉化成後綴表達式

return doEval(list);//真正求值

}

//遇到操作符壓棧，遇到表達式從後綴表達式中彈出兩個數，計算出結果，壓入堆棧

private int doEval(ListString list) {

StackString stack = new StackString();

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 ListString infixExpToPostExp(String exp){//將中綴表達式轉化成為後綴表達式

ListString postExp = new ArrayListString();//存放轉化的後綴表達式的鏈表

StringBuffer numBuffer = new StringBuffer();//用來保存一個數的

StackCharacter opStack = new StackCharacter();//操作符棧

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);

}

}

Java的加減乘除問題

//JAVA編程:四則運算(接收用戶輸入的2個操作數，和運算符)，計算之後，輸出結果~~~~

import java.util.Scanner;

public class 四則運算 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print(“請輸入第一個數字：”);

int a = sc.nextInt();

System.out.print(“請輸入運算符號：”);

String str = sc.next();

char ch = str.charAt(0);

System.out.print(“請輸入第二個數字：”);

int b = sc.nextInt();

switch(ch)

{

case ‘+’:

System.out.println(a+”+”+ b + “=”+(a+b));

break;

case ‘-‘:

System.out.println(a+”-“+ b+ “=”+(a-b));

break;

case ‘*’:

System.out.println(a+”*”+ b+ “=”+(a*b));

break;

case ‘/’:

if(b==0){

System.out.println(“被除數為零，運算無意義!”);

break;

}

else {

System.out.println(a+”/”+ b+ ” = “+(a/b));

break;

}

default:

System.out.println(“運算符是無意義字元！”);

break;

}

}

}

望採納~~~~~~~~

怎麼用java編程，實現分數的加減乘除運算？

java編程實現分數的加減乘除運算的步驟如下：

1、打開eclipse，創建一個Java工程，在此工程里新建一個類；

2、在新建的類中，添加4個運算類；

3、在主方法中調用對應的方法即可完成分數的加減乘除運算了。

具體實現代碼如下：

     public class Demo {

    public static void main(String[] args) {

        System.out.println(jia(1, 2));

        System.out.println(jian(1, 2));

        System.out.println(cheng(1, 2));

        System.out.println(chu(1, 2));

    }

    //加法運算

    private static float jia(float x,float y) {

        return x + y;

    }

    //減法運算

    private static float jian(float x,float y) {

        return x – y;

    }

    //乘法運算

    private static float cheng(float x,float y) {

        return x * y;

    }

    //除法運算

    private static float chu(float x,float y) {

        return x / y;

    }

}

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(scale0){

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(scale0){

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();

}

};