13518219792
import java.util.Collections;
汕头网站建设公司创新互联,汕头网站设计制作，有大型网站制作公司丰富经验。已为汕头上1000+提供企业网站建设服务。企业网站搭建\外贸网站建设要多少钱，请找那个售后服务好的汕头做网站的公司定做！
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();
}
}
import java.util.ArrayList;
import java.util.Stack;
/**itjob
*
* @author yhh
*
*/
public class Calculate {
/**
* 将字符串转化成List
* @param str
* @return
*/
public ArrayListString getStringList(String str){
ArrayListString result = new ArrayListString();
String num = "";
for (int i = 0; i str.length(); i++) {
if(Character.isDigit(str.charAt(i))){
num = num + str.charAt(i);
}else{
if(num != ""){
result.add(num);
}
result.add(str.charAt(i) + "");
num = "";
}
}
if(num != ""){
result.add(num);
}
return result;
}
/**
* 将中缀表达式转化为后缀表达式
* @param inOrderList
* @return
*/
public ArrayListString getPostOrder(ArrayListString inOrderList){
ArrayListString result = new ArrayListString();
StackString stack = new StackString();
for (int i = 0; i inOrderList.size(); i++) {
if(Character.isDigit(inOrderList.get(i).charAt(0))){
result.add(inOrderList.get(i));
}else{
switch (inOrderList.get(i).charAt(0)) {
case '(':
stack.push(inOrderList.get(i));
break;
case ')':
while (!stack.peek().equals("(")) {
result.add(stack.pop());
}
stack.pop();
break;
default:
while (!stack.isEmpty() compare(stack.peek(), inOrderList.get(i))){
result.add(stack.pop());
}
stack.push(inOrderList.get(i));
break;
}
}
}
while(!stack.isEmpty()){
result.add(stack.pop());
}
return result;
}
/**
* 计算后缀表达式
* @param postOrder
* @return
*/
public Integer calculate(ArrayListString postOrder){
Stack stack = new Stack();
for (int i = 0; i postOrder.size(); i++) {
if(Character.isDigit(postOrder.get(i).charAt(0))){
stack.push(Integer.parseInt(postOrder.get(i)));
}else{
Integer back = (Integer)stack.pop();
Integer front = (Integer)stack.pop();
Integer res = 0;
switch (postOrder.get(i).charAt(0)) {
case '+':
res = front + back;
break;
case '-':
res = front - back;
break;
case '*':
res = front * back;
break;
case '/':
res = front / back;
break;
}
stack.push(res);
}
}
return (Integer)stack.pop();
}
/**
* 比较运算符等级
* @param peek
* @param cur
* @return
*/
public static boolean compare(String peek, String cur){
if("*".equals(peek) ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("/".equals(peek) ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("+".equals(peek) ("+".equals(cur) || "-".equals(cur))){
return true;
}else if("-".equals(peek) ("+".equals(cur) || "-".equals(cur))){
return true;
}
return false;
}
public static void main(String[] args) {
Calculate calculate = new Calculate();
String s = "12+(23*3-56+7)*(2+90)/2";
ArrayList result = calculate.getStringList(s); //String转换为List
result = calculate.getPostOrder(result); //中缀变后缀
int i = calculate.calculate(result); //计算
System.out.println(i);
}
}
Java是面向表达式的语言，Java中一个简单表达式可以是下面任意一种：● 常量：7、false。● 单引号括起来的字符字面常量：'A'、'3'。● 双引号括起来的字符串字面常量："foo"、"Java"。● 任何正确声明的变量名：myString、x。● 任何用Java二元运算符（本章稍后将详细讨论）连接起来的两个上述类型的表达式：x+2。● 任何用Java一元运算符（本章稍后将详细讨论）修饰的单个上述类型的表达式：i++。● 任何用小括号括起来的上述类型的表达式：(x+2)。以及另外一些与本书后面将要学到的对象有关的表达式类型。无论多么复杂的表达式都可以由不同类型的简单表达式和括号嵌套组合而成，例如：((((4/x) + y) * 7) + z)。2.9.1 算术运算符 Java语言提供了许多基本的算术运算符，如表2-1所示。表2-1 Java算术运算符运算符描 述+加法-减法*乘法/除法%求余（%左边的操作数除以右边的
操作数所得到的余数，例如10%3=1）+和-运算符也可作为一元运算符用于表示正负数：-3.7、+42。除了简单赋值运算符=，还有许多特定的复合赋值运算符，这些运算符将变量赋值和算术操作合并在一起，如表2-2所示。表2-2 Java复合赋值运算符运算符描 述+=a+=b等价于a=a+b-=a-=b等价于a=a-b*=a*=b等价于a=a*b/=a/=b等价于a=a/b%=a%=b等价于a=a%b最后要介绍的两个算术运算符是一元递增运算符（++）和一元递减运算符（--），用于将整数变量的值加1或减1，或者将浮点数变量的值加1.0或减1.0。称它们为一元运算符是因为它们用于单个变量，而前面讨论的二元运算符则连接两个表达式的值。一元递增运算符和一元递减运算符也可用于将字符变量在Unicode序列中向前或向后移动一个字符位置。例如，在下面的代码片段中，字符变量c的值从'e'递增为'f'：递增和递减运算符可以以前缀或者后缀方式使用。如果运算符放在操作数之前（前缀模式），变量的递增或递减操作将在更新后的变量值被用于任何由它构成的赋值操作之前执行。例如，考虑下面的使用前缀递增运算符的代码片段，假设a和b在程序前面已经声明为int变量：上述代码执行后，变量a的值是2，变量b的值也是2。这是因为在第二行中变量a的递增（从1到2）发生在它的值赋给b之前。因此这行代码在逻辑上等价于下面两行代码： 另一方面，如果运算符放在操作数之后（后缀模式），递增或递减操作发生在原来的变量值被用于任何由它构成的赋值操作之后。看一下以后缀方式使用递增运算符的相同代码片段：上述代码执行后，变量b的值是1，而变量a的值是2。这是因为在第二行中变量a的递增（从1到2）发生在它的值赋给b之后。因此这行代码在逻辑上等价于下面两行代码：下面是一个稍微复杂一点例子，请阅读附加的注释以确保你能够明白x最终是如何被赋值为10的：稍后将会看到，递增和递减运算符通常和循环一起使用。2.9.2 关系和逻辑运算符逻辑表达式以指定的方式比较两个（简单或者复杂）表达式exp1和exp2，决议出一个boolean值true或者false。 Java提供了表2-3所示的关系运算符来创建逻辑表达式。表2-3 Java关系运算符运算符描 述exp1==exp2如果exp1等于exp2，值为true（注意使用双等号测试相等性）exp1exp2如果exp1大于exp2，值为trueexp1=exp2如果exp1大于等于exp2，值为trueexp1exp2如果exp1小于exp2，值为trueexp1修饰逻辑表达式的逻辑运算符。表2-4列出了最常用的逻辑运算符。表2-4 Java逻辑运算符运算符描 述exp1exp2逻辑“与”，仅当exp1和exp2都为true时复合表达式值为trueexp1||exp2逻辑“或”，exp1或exp2值为true时复合表达式值为true!exp逻辑“非”，将逻辑表达式的值从true切换到false，反之亦然下面这个例子用逻辑“与”运算符来编程实现逻辑表达式“如果x大于2.0且y不等于4.0”：逻辑表达式常用于流程控制结构，本章稍后将进行讨论。2.9.3 表达式求值和运算符优先级如同本章前面提到的那样，任何复杂的表达式都可以用分层嵌套的小括号构成，例如(((8 * (y + z)) + y) x)。编译器通常按照从内到外，从左到右的顺序对这样的表达式求值。假设x、y、z按照下面的方式声明并初始化：下面的赋值语句右边的表达式：将像下面这样逐步求值：没有小括号时，根据运算符用于表达式求值的顺序，某些运算符具有高于其他运算符的优先级。例如，乘除法先于加减法执行。通过使用小括号可以强制改变运算符的优先级，括号内的运算符比括号外的先执行。考虑下面的代码片段：代码的第一行没有使用括号，乘法操作比加法操作先执行，因此整个表达式的值为2+12=14，就像我们将表达式明确地写成2+(3*4)一样，当然这样做没有必要。 在代码的第二行，括号被明确地放在操作2+3两边，因此加法操作将首先执行，然后求和结果乘以4作为整个表达式的值，即5*4=20。回到前面的例子注意到和!=运算符优先级高于运算符，因此可以去掉嵌套的括号而变成下面这样：然而，额外的括号并不会对代码造成伤害，事实上它可以使表达式的目的更加清楚。2.9.4 表达式类型表达式类型是表达式最终求值结果的Java类型。例如给定下面的代码片段：表达式(x 2.0) (y != 4.0)求值结果为true，因此表达式(x 2.0) (y != 4.0)称为boolean型表达式。在下面的代码片段中：表达式((8 * (y + z)) + y) * x求值结果为42，因此表达式((8 * (y + z)) + y) * x称为整型表达式。
Java表达式是变量、常量、运算符、方法调用的序列，它执行指定的计算并返回某个确定的值。
其中，运算符按操作数的数目：有一元运算符（++、--）、二元运算符（+、-、等等）和三元运算符（？：），它们分别对应一到三个操作数。
表达式一般按运算符来分：
算术表达式（float x=8.3f、i++）、
关系表达式（37、37）、
布尔逻辑表达式（(54)true、!false）、
位运算表达式(a=34^3)、
赋值表达式、
条件表达式(b=10089?a=ture:a=false)
以及复合表达式。
还有一种叫“表达式语句”，就是在表达式后加上分号作为语句来使用。(int i=123;)
