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