您的位置:

java加减乘除,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();

}

};