尚硅谷图解Java数据结构和算法.pdf
图解.xlsx

1、定义

  • 栈是一个先入后出的有序列表
  • 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶，另一端为固定的一端，称为栈底
  • 最先放入的元素在栈底，且最后出栈。最后放入的元素在栈顶，且最先出栈

三、栈 - 图1
image.png
image.png

2、应用场景

  • 子程序递归调用。如JVM中的虚拟机栈
  • 表达式转换（中缀转后缀）与求值
  • 二叉树的遍历
  • 图的深度优先遍历

image.png

3、实现

用数组实现

思路

  • 定义top表示栈顶，初始值为-1
  • 入栈的操作，先让top++，再放入数组
  • 出栈操作，先取出元素，在让top–
  • top == -1时，栈空
  • top == maxSize-1时，栈满

image.png
代码

  1. package com.atguigu.stack;
  3. import java.util.Scanner;
  5. public class ArrayStackDemo {
  7.     public static void main(String[] args) {
  8.         //测试一下ArrayStack 是否正确
  9.         //先创建一个ArrayStack对象->表示栈
  10.         ArrayStack stack = new ArrayStack(4);
  11.         String key = "";
  12.         boolean loop = true; //控制是否退出菜单
  13.         Scanner scanner = new Scanner(System.in);
  15.         while(loop) {
  16.             System.out.println("show: 表示显示栈");
  17.             System.out.println("exit: 退出程序");
  18.             System.out.println("push: 表示添加数据到栈(入栈)");
  19.             System.out.println("pop: 表示从栈取出数据(出栈)");
  20.             System.out.println("请输入你的选择");
  21.             key = scanner.next();
  22.             switch (key) {
  23.             case "show":
  24.                 stack.list();
  25.                 break;
  26.             case "push":
  27.                 System.out.println("请输入一个数");
  28.                 int value = scanner.nextInt();
  29.                 stack.push(value);
  30.                 break;
  31.             case "pop":
  32.                 try {
  33.                     int res = stack.pop();
  34.                     System.out.printf("出栈的数据是 %d\n", res);
  35.                 } catch (Exception e) {
  36.                     // TODO: handle exception
  37.                     System.out.println(e.getMessage());
  38.                 }
  39.                 break;
  40.             case "exit":
  41.                 scanner.close();
  42.                 loop = false;
  43.                 break;
  44.             default:
  45.                 break;
  46.             }
  47.         }
  49.         System.out.println("程序退出~~~");
  50.     }
  52. }
  54. //定义一个 ArrayStack 表示栈
  55. class ArrayStack {
  56.     private int maxSize; // 栈的大小
  57.     private int[] stack; // 数组，数组模拟栈，数据就放在该数组
  58.     private int top = -1;// top表示栈顶，初始化为-1
  60.     //构造器
  61.     public ArrayStack(int maxSize) {
  62.         this.maxSize = maxSize;
  63.         stack = new int[this.maxSize];
  64.     }
  66.     //栈满
  67.     public boolean isFull() {
  68.         return top == maxSize - 1;
  69.     }
  70.     //栈空
  71.     public boolean isEmpty() {
  72.         return top == -1;
  73.     }
  74.     //入栈-push
  75.     public void push(int value) {
  76.         //先判断栈是否满
  77.         if(isFull()) {
  78.             System.out.println("栈满");
  79.             return;
  80.         }
  81.         top++;
  82.         stack[top] = value;
  83.     }
  84.     //出栈-pop, 将栈顶的数据返回
  85.     public int pop() {
  86.         //先判断栈是否空
  87.         if(isEmpty()) {
  88.             //抛出异常
  89.             throw new RuntimeException("栈空，没有数据~");
  90.         }
  91.         int value = stack[top];
  92.         top--;
  93.         return value;
  94.     }
  95.     //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  96.     public void list() {
  97.         if(isEmpty()) {
  98.             System.out.println("栈空，没有数据~~");
  99.             return;
  100.         }
  101.         //需要从栈顶开始显示数据
  102.         for(int i = top; i >= 0 ; i--) {
  103.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  104.         }
  105.     }    
  106. }

4、应用

表达式求值

image.png
思路
image.png
三、栈 - 图8

  • 准备一个索引index来帮助我们遍历表达式
  • 如果index位置上的元素是一个数字，就直接入栈
  • 如果index位置上的元素是一个符号
    • 如果符号栈为空，直接入栈
    • 如果符号栈不为空
      • index位置上的符号的优先级小于或等于栈顶符号的优先级，则弹出两个数栈中的元素和符号栈中的一个符号，并且进行计算。将运算结果放入数栈中，并将index位置上的符号压入符号栈
      • index位置上的符号的优先级大于符号栈栈顶符号的优先级，则将该符号压入符号栈
  • 当表达式遍历完毕后，就弹出数栈中的2个数字和符号栈中的1个符号进行运算，并将运行结果入栈
  • 最终数栈中只有一个值，这个值便是运算结果
  • 注意：
    • 读取的是字符，所以存入数字前需要减去0的ASCII码
    • 如果数字是多位数，需要一直读，读到下一位不是数字为止，然后将读到的字符进行拼接，然后一起压入数栈

代码
存在的问题：因为栈是用的整型数组，所以计算除法的时候，无法转化成double

  1. package com.atguigu.stack;
  3. public class Calculator {
  5.     public static void main(String[] args) {
  6.         //根据前面老师思路，完成表达式的运算
  7.         String expression = "7*2*2-5+1-5+3-4"; // 15//如何处理多位数的问题？
  8.         //创建两个栈，数栈，一个符号栈
  9.         ArrayStack2 numStack = new ArrayStack2(10);
  10.         ArrayStack2 operStack = new ArrayStack2(10);
  11.         //定义需要的相关变量
  12.         int index = 0;//用于扫描
  13.         int num1 = 0; 
  14.         int num2 = 0;
  15.         int oper = 0;
  16.         int res = 0;
  17.         char ch = ' '; //将每次扫描得到char保存到ch
  18.         String keepNum = ""; //用于拼接 多位数
  19.         //开始while循环的扫描expression
  20.         while(true) {
  21.             //依次得到expression 的每一个字符
  22.             ch = expression.substring(index, index+1).charAt(0);
  23.             //判断ch是什么，然后做相应的处理
  24.             if(operStack.isOper(ch)) {//如果是运算符
  25.                 //判断当前的符号栈是否为空
  26.                 if(!operStack.isEmpty()) {
  27.                     //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
  28.                     //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
  29.                     if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
  30.                         num1 = numStack.pop();
  31.                         num2 = numStack.pop();
  32.                         oper = operStack.pop();
  33.                         res = numStack.cal(num1, num2, oper);
  34.                         //把运算的结果如数栈
  35.                         numStack.push(res);
  36.                         //然后将当前的操作符入符号栈
  37.                         operStack.push(ch);
  38.                     } else {
  39.                         //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
  40.                         operStack.push(ch);
  41.                     }
  42.                 }else {
  43.                     //如果为空直接入符号栈..
  44.                     operStack.push(ch); // 1 + 3
  45.                 }
  46.             } else { //如果是数，则直接入数栈
  48.                 //numStack.push(ch - 48); //? "1+3" '1' => 1
  49.                 //分析思路
  50.                 //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  51.                 //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
  52.                 //3. 因此我们需要定义一个变量 字符串，用于拼接
  54.                 //处理多位数
  55.                 keepNum += ch;
  57.                 //如果ch已经是expression的最后一位，就直接入栈
  58.                 if (index == expression.length() - 1) {
  59.                     numStack.push(Integer.parseInt(keepNum));
  60.                 }else{
  62.                     //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
  63.                     //注意是看后一位，不是index++
  64.                     if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
  65.                         //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
  66.                         numStack.push(Integer.parseInt(keepNum));
  67.                         //重要的!!!!!!, keepNum清空
  68.                         keepNum = "";
  70.                     }
  71.                 }
  72.             }
  73.             //让index + 1, 并判断是否扫描到expression最后.
  74.             index++;
  75.             if (index >= expression.length()) {
  76.                 break;
  77.             }
  78.         }
  80.         //当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
  81.         while(true) {
  82.             //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
  83.             if(operStack.isEmpty()) {
  84.                 break;
  85.             }
  86.             num1 = numStack.pop();
  87.             num2 = numStack.pop();
  88.             oper = operStack.pop();
  89.             res = numStack.cal(num1, num2, oper);
  90.             numStack.push(res);//入栈
  91.         }
  92.         //将数栈的最后数，pop出，就是结果
  93.         int res2 = numStack.pop();
  94.         System.out.printf("表达式 %s = %d", expression, res2);
  95.     }
  97. }
  99. //先创建一个栈,直接使用前面创建好
  100. //定义一个 ArrayStack2 表示栈, 需要扩展功能
  101. class ArrayStack2 {
  102.     private int maxSize; // 栈的大小
  103.     private int[] stack; // 数组，数组模拟栈，数据就放在该数组
  104.     private int top = -1;// top表示栈顶，初始化为-1
  106.     //构造器
  107.     public ArrayStack2(int maxSize) {
  108.         this.maxSize = maxSize;
  109.         stack = new int[this.maxSize];
  110.     }
  112.     //增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
  113.     public int peek() {
  114.         return stack[top];
  115.     }
  117.     //栈满
  118.     public boolean isFull() {
  119.         return top == maxSize - 1;
  120.     }
  121.     //栈空
  122.     public boolean isEmpty() {
  123.         return top == -1;
  124.     }
  125.     //入栈-push
  126.     public void push(int value) {
  127.         //先判断栈是否满
  128.         if(isFull()) {
  129.             System.out.println("栈满");
  130.             return;
  131.         }
  132.         top++;
  133.         stack[top] = value;
  134.     }
  135.     //出栈-pop, 将栈顶的数据返回
  136.     public int pop() {
  137.         //先判断栈是否空
  138.         if(isEmpty()) {
  139.             //抛出异常
  140.             throw new RuntimeException("栈空，没有数据~");
  141.         }
  142.         int value = stack[top];
  143.         top--;
  144.         return value;
  145.     }
  146.     //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  147.     public void list() {
  148.         if(isEmpty()) {
  149.             System.out.println("栈空，没有数据~~");
  150.             return;
  151.         }
  152.         //需要从栈顶开始显示数据
  153.         for(int i = top; i >= 0 ; i--) {
  154.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  155.         }
  156.     }
  157.     //返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
  158.     //数字越大，则优先级就越高.
  159.     public int priority(int oper) {
  160.         if(oper == '*' || oper == '/'){
  161.             return 1;
  162.         } else if (oper == '+' || oper == '-') {
  163.             return 0;
  164.         } else {
  165.             return -1; // 假定目前的表达式只有 +, - , * , /
  166.         }
  167.     }
  168.     //判断是不是一个运算符
  169.     public boolean isOper(char val) {
  170.         return val == '+' || val == '-' || val == '*' || val == '/';
  171.     }
  172.     //计算方法
  173.     public int cal(int num1, int num2, int oper) {
  174.         int res = 0; // res 用于存放计算的结果
  175.         switch (oper) {
  176.         case '+':
  177.             res = num1 + num2;
  178.             break;
  179.         case '-':
  180.             res = num2 - num1;// 注意顺序
  181.             break;
  182.         case '*':
  183.             res = num1 * num2;
  184.             break;
  185.         case '/':
  186.             res = num2 / num1;
  187.             break;
  188.         default:
  189.             break;
  190.         }
  191.         return res;
  192.     }
  194. }

5、前缀 中缀 后缀（逆波兰）表达式

前缀表达式（波兰表达式）

image.png
image.png

中缀

image.png

后缀（逆波兰表达式）

后缀表达式运算方法

  • 从左向右读取表达式
    • 遇到数字就压入栈中
    • 遇到运算符就弹出栈顶和次顶元素。用次顶元素 运算符 栈顶元素，并将运算结果压入栈中，直到栈为空，最终结果就是运算结果

image.png

逆波兰计算器

image.png
代码实现

  1. package com.luyi.DataStructures.stack;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.List;
  6. import java.util.Stack;
  9. public class PolandNotation {
  11.     public static void main(String[] args) {
  12.         // 先定义一个 逆波兰表达式
  13.         //(3+4)*5-6 => 3 4 + 5 * 6 -
  14.         // 为了方便 中间用空格隔开
  15.         String suffixExpression = "3 4 + 5 * 6 -";
  16.         // 1 现将suffixExpression 放到一个ArrayList中
  17.         // 2 将ArrayList 传递一个方法 遍历ArrayList 配合栈 完成计算
  18.         List<String> rpnList=getListString(suffixExpression);
  19.         System.out.println("rpnList:"+rpnList);
  20.         System.out.println("结果为: "+calculator(rpnList) );
  22.     }
  24.     // 将一个逆波兰表达式 一次将数据和运算符放入一个 ArrayList中
  25.     public static List<String> getListString(String suffixExpression) {
  26.         // 将suffixExpression 按空格分隔
  27.         String[] split = suffixExpression.split(" ");
  28.         List<String> list = new ArrayList<String>(Arrays.asList(split));
  29.         return list;
  30.     }
  31.     // 完成对逆波兰表达式的运算
  32.     // 1．从左至右扫描，将 3 和 4 压入堆栈；
  33.     // 2．遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
  34.     // 3．将 5 入栈；
  35.     // 4．接下来是×运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；
  36.     // 5．将 6 入栈；
  37.     // 6．最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果
  38.     public static int calculator(List<String> ls) {
  39.         // 创建一个栈 只需要一个
  40.         Stack<String> stack = new Stack<>();
  41.         // 遍历 ls
  42.         for(String item : ls) {
  43.             // 使用一个正则表达式取出数
  44.             if(item.matches("\\d+")) { // 匹配的是多位数
  45.                 // 入栈
  46.                 stack.push(item);
  47.             }else { // 如果是运算符
  48.                 // pop出两个数并运算
  49.                 int b = Integer.parseInt(stack.pop());
  50.                 int a = Integer.parseInt(stack.pop());
  51.                 int res = 0;
  52.                 switch (item) {
  53.                     case "+":
  54.                         res = a+b;
  55.                         break;
  56.                     case "-":
  57.                         res = a-b;
  58.                         break;
  59.                     case "*":
  60.                         res = a*b;
  61.                         break;
  62.                     case "/":
  63.                         res = a/b;
  64.                         break;
  65.                     default:
  66.                         throw new RuntimeException("符号有问题");
  67.                 }
  68.                 stack.push(res+"");
  69.             }
  70.         }
  71.         return Integer.parseInt(stack.pop());
  72.     }
  73. }

中缀表达式转后缀表达式

image.pngimage.pngimage.png
中缀表达式转后缀表达式

  • 从左向右读取中缀表达式，并且创建栈s和队列q
  • 如果读到的元素的数字，就直接入队放入q中
  • 如果读到的是运算符（运算符判定）
    • 如果s为空，则将该运算符压入s
    • 如果s不为空
      • 如果该运算符为左括号，则直接压入s
      • 如果该运算符为右括号，则将s中的元素依次出栈并入队到q中，直到遇见左括号为止（括号不放入q中）
      • 如果该运算符的优先级高于s栈顶的运算符，则将该元素压入s
      • 如果该运算符的优先级小于等于s栈顶的运算符，则弹出s栈顶的元素，并将其放入q中，该运算符重新判定入栈操作（运算符判定步骤）
  • 如果中缀表达式已经读取完毕，则将s中的元素依次出栈，放入q中
  • q中的元素依次出队，该顺序即为后缀表达式

代码

  1. package com.luyi.DataStructures.stack;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Stack;
  8. public class PolandNotation {
  10.     public static void main(String[] args) {
  12.         // 完成将中缀表达式转成后缀代达式的功能
  13.         // 1.  1+((2+3)*4)-5   =>     1 2 3 + 4 * + 5 -
  14.         // 2.  因为直接对Str 进行操作不方便  因此 先将 1+((2+3)*4)-5 转成中缀表达式对应的List
  15.         //     即  ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  16.         // 3.  将得到的中缀表达式的list => 后缀表达式的List
  17.         // 4.  ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =>  ArrayList [1,2,3,+,4,*,+,5]
  18.         String expression = "1+((2+3)*4)-5";
  19.         System.out.println("中缀表达式:"+ toInfixExpression(expression));
  20.         List<String> parseSuffixExpressList = parseSuffixExpressionList(toInfixExpression(expression));
  21.         System.out.println("逆波兰表达式:" +parseSuffixExpressList );
  22.         //结果
  23.         System.out.println("expression:"+expression+"="+ calculator(parseSuffixExpressList));
  26.         // 先定义一个 逆波兰表达式
  27.         //(3+4)*5-6 => 3 4 + 5 * 6 -
  28.         //(30+4)*5-6 => 30 4 + 5 * 6 -
  29.         //4*5-8+60+8/2 =>  4 5 * 8 - 60 + 8 2 / +
  30.         // 为了方便 中间用空格隔开
  31.         String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
  32.         // 1 现将suffixExpression 放到一个ArrayList中
  33.         // 2 将ArrayList 传递一个方法 遍历ArrayList 配合栈 完成计算
  34.         List<String> rpnList=getListString(suffixExpression);
  35.         System.out.println("rpnList:"+rpnList);
  36.         System.out.println("结果为: "+calculator(rpnList) );
  38.     }
  39.     // 将 中缀表达式转成对应的List
  40.     public static List<String> toInfixExpression(String s) {
  41.         // 定义一个ArrayList 存放中缀表达式的内容
  42.         List<String> arrayList = new ArrayList<String>();
  43.         int i = 0;
  44.         String str; // 做对多位数的拼接
  45.         char c; // 每遍历到一个字符放入c中
  46.         do {
  47.             // 如果c是一个非数字 直接加入到ls
  48.             if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) < 57 ){
  49.                 arrayList.add(c + "");
  50.                 i++;
  51.             }else { // 如果是一个数 需要考虑多位数的问题
  52.                 str = ""; // str 置空
  53.                 while (i < s.length() && (s.charAt(i) >= 48 && s.charAt(i) <= 57)) {
  54.                     str += c;
  55.                     i++;
  56.                 }
  57.                 arrayList.add(str);
  58.             }
  59.         }while (i < s.length());
  60.         return arrayList;
  61.     }
  63.     // 将得到的中缀表达式的list => 后缀表达式的List ls=ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  64.     public static List<String> parseSuffixExpressionList(List<String> ls) {
  65.         // 定义两个栈
  66.         Stack<String> s1 = new Stack<String>(); // 符号栈
  67.         // 第二个栈 在整个转换过程中 没有pop操作, 而且后面我们号需要逆序输出 还要逆序输出 我们同 List<String> s2 代替
  68.         // Stack<String> s2 = new Stack<String>();
  69.         List<String> s2 = new ArrayList<String>();
  71.         // 遍历ls
  72.         for (String item : ls) {
  73.             // 如果是一个数 加入s2
  74.             if(item.matches("\\d+")) {
  75.                 s2.add(item);
  76.             }else if (item.equals("(")) {
  77.                 s1.push(item);
  78.             }else if (item.equals(")")) {
  79.                 //如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
  80.                 while (!s1.peek().equals("(")){
  81.                     s2.add(s1.pop());
  82.                 }
  83.                 s1.pop(); // 弹出 (
  84.             }else {
  85.                 // 当item的优先级 小于 s1栈顶的运算符的优先级 将 s1 栈顶的运算符弹出并加入到 s2 中，再次转到(4.1)与 s1 中新的栈顶运算符相比较
  86.                 while (s1.size() != 0 && (Operation.getValue(item) <= Operation.getValue(s1.peek()))) {
  87.                     s2.add(s1.pop());
  88.                 }
  89.                 // 还需要将Item入栈
  90.                 s1.push(item);
  91.             }
  92.         }
  93.         // 将s1的剩余的运算符加入s2中
  94.         while (s1.size() !=0){
  95.             s2.add(s1.pop());
  96.         }
  97.         return s2; // 因为是存在list中  不用逆序 正常输出就是逆波兰表达式
  98.     }
  99.     // 将一个逆波兰表达式 一次将数据和运算符放入一个 ArrayList中
  100.     public static List<String> getListString(String suffixExpression) {
  101.         // 将suffixExpression 按空格分隔
  102.         String[] split = suffixExpression.split(" ");
  103.         List<String> list = new ArrayList<String>(Arrays.asList(split));
  104.         return list;
  105.     }
  107.     // 完成对逆波兰表达式的运算
  108.     // 1．从左至右扫描，将 3 和 4 压入堆栈；
  109.     // 2．遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
  110.     // 3．将 5 入栈；
  111.     // 4．接下来是×运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；
  112.     // 5．将 6 入栈；
  113.     // 6．最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果
  114.     public static int calculator(List<String> ls) {
  115.         // 创建一个栈 只需要一个
  116.         Stack<String> stack = new Stack<>();
  117.         // 遍历 ls
  118.         for(String item : ls) {
  119.             // 使用一个正则表达式取出数
  120.             if(item.matches("\\d+")) { // 匹配的是多位数
  121.                 // 入栈
  122.                 stack.push(item);
  123.             }else { // 如果是运算符
  124.                 // pop出两个数并运算
  125.                 int b = Integer.parseInt(stack.pop());
  126.                 int a = Integer.parseInt(stack.pop());
  127.                 int res = 0;
  128.                 switch (item) {
  129.                     case "+":
  130.                         res = a+b;
  131.                         break;
  132.                     case "-":
  133.                         res = a-b;
  134.                         break;
  135.                     case "*":
  136.                         res = a*b;
  137.                         break;
  138.                     case "/":
  139.                         res = a/b;
  140.                         break;
  141.                     default:
  142.                         throw new RuntimeException("符号有问题");
  143.                 }
  144.                 stack.push(res+"");
  145.             }
  146.         }
  147.         return Integer.parseInt(stack.pop());
  148.     }
  149. }
  150. // 编写一个类 Operation 返回一个运算符 对应的优先级
  151. class Operation {
  152.     private static int ADD = 1;
  153.     private static int SUB = 1;
  154.     private static int MUL = 2;
  155.     private static int DIV = 2;
  157.     // 写一个方法 返回一个优先级数字
  158.     public static int getValue(String operation) {
  159.         int result = 0;
  160.         switch (operation){
  161.             case "+":
  162.                 result = ADD;
  163.                 break;
  164.             case "-":
  165.                 result = SUB;
  166.                 break;
  167.             case "*":
  168.                 result = MUL;
  169.                 break;
  170.             case "/":
  171.                 result = DIV;
  172.                 break;
  173.             default:
  174.                 System.out.println("不存在该运算符");
  175.                 break;
  176.         }
  177.         return result;
  178.     }
  179. }