您的位置:

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编写的实现加减乘除的程序如下

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

public class Calculator extends JFrame implements ActionListener{

 JLabel jl1=new JLabel("第一个数");

 JLabel jl2=new JLabel("运算符");

 JLabel jl3=new JLabel("第二个数");

 JLabel jl4=new JLabel("结果:");

 JTextField jtf1=new JTextField(8);

 JTextField jtf2=new JTextField(8);

 JTextField jtf3=new JTextField(8);

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

 JComboBoxString jcb=new JComboBoxString(a);

 JButton jb1=new JButton("计算");

 JButton jb2=new JButton("退出");

 JPanel jp=new JPanel();

 Calculator(){

  setTitle("计算器");

  jb1.addActionListener(this);

  jb2.addActionListener(this);

  jp.setLayout(null);

  jl1.setBounds(30, 30, 80, 20);

  jl2.setBounds(110, 30, 80, 20);

  jl3.setBounds(190, 30, 80, 20);

  jtf1.setBounds(30, 60, 70, 20);

  jcb.setBounds(110, 60, 70,20);

  jtf2.setBounds(190, 60, 70, 20);

  jl4.setBounds(80, 110, 40, 20);

  jtf3.setBounds(110, 110, 100, 20);

  jb1.setBounds(60, 160, 60, 25);

  jb2.setBounds(170, 160, 60, 25);

  jp.add(jl1);jp.add(jl2);jp.add(jl3);

  jp.add(jtf1);jp.add(jcb);jp.add(jtf2);

  jp.add(jl4);jp.add(jtf3);

  jp.add(jb1);jp.add(jb2);

  add(jp,BorderLayout.CENTER);

  setSize(300, 300);

  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  setLocationRelativeTo(null);

  setVisible(true);

 }

 public static void main(String[] args) {

  new Calculator();

 }

 @Override

 public void actionPerformed(ActionEvent ae) {

  if(ae.getSource()==jb1){

   String c=((String) jcb.getSelectedItem()).trim();

   if(jtf1.getText().trim().equals("")){

    JOptionPane.showMessageDialog(this, "第一个数不能为空");

    jtf1.requestFocus();

    return;

   }

   if(jtf2.getText().trim().equals("")){

    JOptionPane.showMessageDialog(this, "第二个数不能为空");

    jtf2.requestFocus();

    return;

   }

   double num1=Double.parseDouble(jtf1.getText().trim());

   double num2=Double.parseDouble(jtf2.getText().trim());

   double num3 = 0;

   switch(c){

    case "+":num3=num1+num2;break;

    case "-":num3=num1-num2;break;

    case "*":num3=num1*num2;break;

    case "/":

     if(num2==0){

      JOptionPane.showMessageDialog(this, "除数不能为0");

      jtf2.requestFocus();

      return;

     }else{

      num3=num1/num2;

      break;

     }

   }

   jtf3.setText(String.valueOf(num3));

  }

  if(ae.getSource()==jb2){

   System.exit(0);

  }

 }

}

运行结果

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

}

};

怎么用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;

    }

}