今天给各位分享java表达式的值的知识,其中也会对java函数表达式进行解释,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!
本文目录一览:
1、java 表达式的结果2、java实现算术表达式求值3、java求表达式的值4、Java表达式的值及数据类型5、表达式求值 数据结构 java实现6、Java 中可以输出表达式的值吗 如i+5*j
java 表达式的结果
java 表达式,由变量,literal和运算符号组合而成.java 总共提供大约30种操作符.下面一一介绍.
1、算术运算
算术运算符有+,-,*,/,% 五种。对于整数来说,算术运算符得到的结果只会是int,为什么呢?因为怕运算完后的结果会超出原来数据类型的范围.
2、比较运算
比较运算符有大于(),小于(),大于等于(=),小于等于(=),等于(==)和不等于(!=).比较运算的结果一定只有两种,true或false,也就是boolean类型的literal.
不是只有数据才能比较大小,字符也可以,另外等于和不等于也可以用在非基本数据类型之间,如类,对象,字符串,数组等.String的比较不能直接用==.因为它是一个类,不是一种数据类型.
3、逻辑运算
逻辑运算符有与“”,或“||”,非“!”,其中“”和“”是短路逻辑操作符。逻辑运算还有“”“|”“^”等三个按操作符。
4、递加、递减运算
递加“++”,递减“–”,这个与C的语法一样,在使用递加、递减时要特别注意它是放在变量的前面还是后面。如果是如“++a”,java会先将a的值加加,再把新的数值拿去做别的运算。而如果是“a++”的话相反,先把a的值拿去做运算后再将a的值++写入内存。“–”的做法也是一样。
5、赋值运算
“=”是赋值操作符。通常把“=”称为赋值,而不称作等于。赋值操作符的优先级是所有操作符中最低的.还要注意赋值运算的自动类型转换是放大类型转换,不是缩小类型转换,否则编译时要报错.
6、位运算
其中三种“”“|”“^”其实已经在逻辑运算中提到,另外还有就是互补“~”,“~”有点像逻辑非“!”,只不过“!”用在boolean类型,而“~”用在int类型,也就是按位取反。
7、位移运算
右移“”和左移“”。另外还有无符号的右移“”,跟右移运算类似,不过不管正负数,全在左边缺少的地方补0,注意它只能用在int,long。
综上,表达式有双重功能,执行表达式的运算和返回值。下表说明了Java操作符的优先级:
后缀操作符 [] . (params) expr++ expr–
一元操作符 ++expr –expr +expr -expr ~ !
新建 new (type)expr
乘除 * / %
加减 + –
移位
关系 = = instanceof
等 == !=
位与
位异或 ^
位同或 |
逻辑与
逻辑或 ||
条件 ? :
赋值 = += -= *= /= %= = ^= |= = = =
java实现算术表达式求值
import java.util.Collections;
import java.util.Stack;
public class Calculator {
private StackString postfixStack = new StackString();//后缀式栈
private StackCharacter opStack = new StackCharacter();//运算符栈
private int [] operatPriority = new int[] {0,3,2,1,-1,1,0,2};//运用运算符ASCII码-40做索引的运算符优先级
public static void main(String[] args) {
System.out.println(5+12*(3+5)/7.0);
Calculator cal = new Calculator();
String s = “5+12*(3+5)/7”;
double result = cal.calculate(s);
System.out.println(result);
}
/**
* 按照给定的表达式计算
* @param expression 要计算的表达式例如:5+12*(3+5)/7
* @return
*/
public double calculate(String expression) {
StackString resultStack = new StackString();
prepare(expression);
Collections.reverse(postfixStack);//将后缀式栈反转
String firstValue ,secondValue,currentValue;//参与计算的第一个值,第二个值和算术运算符
while(!postfixStack.isEmpty()) {
currentValue = postfixStack.pop();
if(!isOperator(currentValue.charAt(0))) {//如果不是运算符则存入操作数栈中
resultStack.push(currentValue);
} else {//如果是运算符则从操作数栈中取两个值和该数值一起参与运算
secondValue = resultStack.pop();
firstValue = resultStack.pop();
String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
resultStack.push(tempResult);
}
}
return Double.valueOf(resultStack.pop());
}
/**
* 数据准备阶段将表达式转换成为后缀式栈
* @param expression
*/
private void prepare(String expression) {
opStack.push(‘,’);//运算符放入栈底元素逗号,此符号优先级最低
char[] arr = expression.toCharArray();
int currentIndex = 0;//当前字符的位置
int count = 0;//上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
char currentOp ,peekOp;//当前操作符和栈顶操作符
for(int i=0;iarr.length;i++) {
currentOp = arr[i];
if(isOperator(currentOp)) {//如果当前字符是运算符
if(count 0) {
postfixStack.push(new String(arr,currentIndex,count));//取两个运算符之间的数字
}
peekOp = opStack.peek();
if(currentOp == ‘)’) {//遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
while(opStack.peek() != ‘(‘) {
postfixStack.push(String.valueOf(opStack.pop()));
}
opStack.pop();
} else {
while(currentOp != ‘(‘ peekOp != ‘,’ compare(currentOp,peekOp) ) {
postfixStack.push(String.valueOf(opStack.pop()));
peekOp = opStack.peek();
}
opStack.push(currentOp);
}
count = 0;
currentIndex = i+1;
} else {
count++;
}
}
if(count 1 || (count == 1 !isOperator(arr[currentIndex]))) {//最后一个字符不是括号或者其他运算符的则加入后缀式栈中
postfixStack.push(new String(arr,currentIndex,count));
}
while(opStack.peek() != ‘,’) {
postfixStack.push(String.valueOf( opStack.pop()));//将操作符栈中的剩余的元素添加到后缀式栈中
}
}
/**
* 判断是否为算术符号
* @param c
* @return
*/
private boolean isOperator(char c) {
return c == ‘+’ || c == ‘-‘ || c == ‘*’ || c == ‘/’ || c == ‘(‘ ||c == ‘)’;
}
/**
* 利用ASCII码-40做下标去算术符号优先级
* @param cur
* @param peek
* @return
*/
public boolean compare(char cur,char peek) {// 如果是peek优先级高于cur,返回true,默认都是peek优先级要低
boolean result = false;
if(operatPriority[(peek)-40] = operatPriority[(cur) – 40]) {
result = true;
}
return result;
}
/**
* 按照给定的算术运算符做计算
* @param firstValue
* @param secondValue
* @param currentOp
* @return
*/
private String calculate(String firstValue,String secondValue,char currentOp) {
String result = “”;
switch(currentOp) {
case ‘+’:
result = String.valueOf(ArithHelper.add(firstValue, secondValue));
break;
case ‘-‘:
result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
break;
case ‘*’:
result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
break;
case ‘/’:
result = String.valueOf(ArithHelper.div(firstValue, secondValue));
break;
}
return result;
}
}
public class ArithHelper {
// 默认除法运算精度
private static final int DEF_DIV_SCALE = 16;
// 这个类不能实例化
private ArithHelper() {
}
/**
* 提供精确的加法运算。
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
public static double add(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
public static double sub(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1
* 被乘数
* @param v2
* 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
public static double mul(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(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);
}
public static double div(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供(相对)精确的除法运算。当发生除不尽的情况时,由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”);
}
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, java.math.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”);
}
java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
java.math.BigDecimal one = new java.math.BigDecimal(“1”);
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double round(String v, int scale) {
if (scale 0) {
throw new IllegalArgumentException(“The scale must be a positive integer or zero”);
}
java.math.BigDecimal b = new java.math.BigDecimal(v);
java.math.BigDecimal one = new java.math.BigDecimal(“1”);
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
}
java求表达式的值
j+k = 20+30 =50 i=10 ij+k 是成立,!表示取反的意思,也就是原来成立的,现在不成立了
所以 !(ij+k) 不成立。
!(i+10=j) 同理判断为 i+10=j成立,加上!后不成立了
所以 两个都是假的 II要求至少一个真为真 所以 结果为false。
Java表达式的值及数据类型
System.out.println(1+4/5+(int)5.2/2.5);
4/5为整数除法,结果为0。(int)5.2/2.5是先将5.2转换为整型得5,再除以2.5,得2.0(注意结果为浮点数),所以最后结果是浮点数,3.0
System.out.println(1+4/5+(int)(5.2/2.5));
由于5.2/2.5加了括号,所以是先做浮点除法,再转换为整型,最后结果也是整型,得3
System.out.println(1+4/5+5.2/2.5);
1+0+2.08=3.08,没什么好说的
System.out.println(1.0+4/5+5.2/2.5);
1.0是浮点数,4/5先按整数除法来,在转换为浮点数(得0.0),5.2/2.5=2.08,结果是浮点数3.08
System.out.println(1+4/5.0+5.2/2.5);
由于4/5.0中的除数是浮点数,所以这一步按浮点数除法来计算,得0.8,结果为3.88
表达式求值 数据结构 java实现
1. 定义优先级和优先级表
Java代码
/**
* 运算符优先权
*/
public enum Precede {
/**
* 优先权高
*/
LARGER,
/**
* 优先权低
*/
LESS;
/**
* 优先级表
* + – * /
* +
* –
* *
* /
*/
private static Precede[][] precedes = new Precede[4][4];
static {
// 根据优先级表初始化precedes数组
for (int i = 0; i precedes.length; i++) {
for (int j = 0; j precedes[i].length; j++) {
if ((i == 0 || i == 1) j 1) {
precedes[i][j] = LESS;
} else {
precedes[i][j] = LARGER;
}
}
}
}
/**
* 判断2个运算符的优先级
*/
public static Precede judgePrecede(char operand1, char operand2) {
int left = getIndex(operand1);
int right = getIndex(operand2);
return precedes[left][right];
}
/**
* 获取运算符对应的数组索引
*/
private static int getIndex(char operand) {
switch (operand) {
case ‘+’:
return 0;
case ‘-‘:
return 1;
case ‘*’:
return 2;
case ‘/’:
return 3;
default:
throw new IllegalArgumentException();
}
}
}
2. 表达式求值
Java代码
/**
* 整数表达式运算
*/
public class EvaluateExpression {
/**
* 表达式
*/
private String expression;
/**
* 最初的表达式
*/
private String initExpression;
/**
* 运算符栈
*/
private MyStackCharacter optr = new MyArrayStackCharacter();
/**
* 操作数栈
*/
private MyStackInteger opnd = new MyArrayStackInteger();
/**
* 表明下一个是否应该是数字
*/
private boolean numberNext;
public EvaluateExpression(String expression) {
this.expression = expression;
this.initExpression = expression;
numberNext = true;
}
/**
* 求值
*/
public Integer evaluate() {
delBlank();
handleParentheses();
while (true) {
if (“”.equals(expression)) {
break;
}
if (expression.matches(“^-?\\d+.*$”) numberNext) {
opnd.push(getInteger());
continue;
} else {
Character operand = expression.charAt(0);
numberNext = true;
expression = expression.substring(1);
Character pop = optr.pop();
if (pop == null) {
optr.push(operand);
continue;
} else {
Precede precede = Precede.judgePrecede(pop, operand);
switch (precede) {
// 优先级高时运算前2个操作数
case LARGER: {
optr.push(operand);
Integer next = opnd.pop();
Integer last = opnd.pop();
evaluateNow(last, pop, next);
break;
}
// 优先级低时运算前一个操作数和后一个操作数
case LESS: {
optr.push(pop);
Integer last = opnd.pop();
Integer next = getInteger();
evaluateNow(last, operand, next);
break;
}
}
}
}
}
// 运算结果
Integer result = null;
if (optr.length() == 0 opnd.length() == 1) {
result = opnd.pop();
} else if (optr.length() == 1 opnd.length() == 2) {
Integer next = opnd.pop();
Integer last = opnd.pop();
evaluateNow(last, optr.pop(), next);
result = opnd.pop();
} else {
throw new RuntimeException();
}
return result;
}
/**
* 进行实际的运算,并将结果入栈
*/
private void evaluateNow(Integer last, Character operand, Integer next) {
switch (operand) {
case ‘+’:
opnd.push(last + next);
break;
case ‘-‘:
opnd.push(last – next);
break;
case ‘*’:
opnd.push(last * next);
break;
case ‘/’:
opnd.push(last / next);
break;
}
}
/**
* 获得表达式开头部分的整数
*/
private Integer getInteger() {
StringBuilder sb = new StringBuilder();
int count = 0; // 整数位
boolean lessZero = false; // 是否是负数
if (expression.startsWith(“-“)) {
sb.append(“-“);
count++;
lessZero = true;
}
int i = (lessZero ? 1 : 0);
for (; i expression.length(); i++) {
char c = expression.charAt(i);
if (c = ‘0’ c = ‘9’) {
sb.append(c);
count++;
} else {
break;
}
}
expression = expression.substring(count);
numberNext = false;
return Integer.valueOf(sb.toString());
}
/**
* 处理括号. 将括号内的字符串作为子表达式计算.
*/
private void handleParentheses() {
while (expression.contains(“(“)) {
// 左括号的索引
int left = 0;
// 右括号的索引
int right = 0;
// 左括号的数量
int count = 0;
// 求出左括号索引
left = expression.indexOf(‘(‘);
// 求出对应的右括号索引
for (int i = left; i expression.length(); i++) {
char c = expression.charAt(i);
if (c == ‘)’) {
count–;
// count为0时才是对应的右括号
if (count == 0) {
right = i;
break;
}
} else if (c == ‘(‘) {
count++;
} else {
continue;
}
}
// 左右括号之间是一个子表达式, 计算子表达式的值,并根据结果构造出新的表达式
EvaluateExpression evaluateExpression = new EvaluateExpression(expression.substring(left + 1, right));
expression = expression.substring(0, left) + evaluateExpression.evaluate()
+ expression.substring(right + 1);
}
}
/**
* 删除表达式中的空白字符
*/
private void delBlank() {
expression = expression.replaceAll(“\\s”, “”);
}
@Override
public String toString() {
return initExpression;
}
}
3. 进行测试
Java代码
@Test
public void testEvaluate() {
EvaluateExpression expression = new EvaluateExpression(“1 + 2 “);
System.out.println(expression + ” = ” + expression.evaluate());
expression = new EvaluateExpression(“4 + 2 * 3 – 10 / 5”);
System.out.println(expression + ” = ” + expression.evaluate());
expression = new EvaluateExpression(“(1+2) * (4 + 5) – (9 / 7)”);
System.out.println(expression + ” = ” + expression.evaluate());
expression = new EvaluateExpression(“(1 + (3 * (4 – 9)))”);
System.out.println(expression + ” = ” + expression.evaluate());
expression = new EvaluateExpression(“(1 + (3 * (4 – 9))) + (3 * (2 + 3))”);
System.out.println(expression + ” = ” + expression.evaluate());
}
测试的结果为:
1 + 2 = 3
4 + 2 * 3 – 10 / 5 = 8
(1+2) * (4 + 5) – (9 / 7) = 26
(1 + (3 * (4 – 9))) = -14
(1 + (3 * (4 – 9))) + (3 * (2 + 3)) = 1
Java 中可以输出表达式的值吗 如i+5*j
int i=1,j=2;
System.out.println(i+5*j);//11
java中,表达式是一种运算,运算结果是一个确定的值。只要你使用这个表达式得到一个结果值,那就可以用。
关于java表达式的值和java函数表达式的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。