新萄京计算机网络

 新萄京计算机网络     |      2020-03-17

不查询数据记录,直接更改

  1 import java.util.ArrayList;
  2 import java.util.List;
  3 import java.util.Stack;
  4 import java.util.regex.Matcher;
  5 import java.util.regex.Pattern;
  6 
  7 public class ParseCalcMode {
  8 
  9     public static List parse(String calcMode) {
 10         List elementsList = new ArrayList();
 11         Pattern p = Pattern.compile("(\d+)|([-+*/])|([\(\)])");
 12 
 13         Matcher m = p.matcher(calcMode);
 14         while (m.find()) {
 15             elementsList.add(m.group(0));
 16             //            System.out.println(m.groupCount());
 17         }
 18         return elementsList;
 19     }
 20 
 21     /**
 22      * 进行混合运算
 23      * 
 24      * @param srcStack
 25      * @return
 26      */
 27 
 28     private static String calcMix(Stack srcStack) {
 29         Stack destStack = new Stack();
 30         // 否则有一个完成的带括计算式,则执行计算操作
 31         String data1;
 32         String opr;
 33         String data2;
 34         //
 35         String elem = (String) srcStack.pop();
 36 
 37         // 先执行乘除表式
 38         while (!elem.equals("(")) {
 39             if ("*".equals(elem) || "/".equals(elem)) {
 40 
 41                 data1 = (String) srcStack.pop();
 42                 opr = elem;
 43                 data2 = (String) destStack.pop();
 44 
 45                 Stack tmpStack = new Stack();
 46                 // 如果是连续的乘除,则把连续乘除表达式存入一个临时栈中,待整个连续乘除表达时放完后计算临栈
 47                 while (!srcStack.isEmpty()
 48                         && (srcStack.peek().equals("*") || srcStack.peek().equals("/"))) {
 49                     // 第一次放时
 50                     if (tmpStack.isEmpty()) {
 51                         tmpStack.push(data2);
 52                         tmpStack.push(elem);
 53                         tmpStack.push(data1);
 54                     } else {
 55                         tmpStack.push(srcStack.pop());
 56                         tmpStack.push(srcStack.pop());
 57                     }
 58                     System.out.println("临时栈 tmpStack=" + tmpStack);
 59                 }
 60 
 61                 // 如果不是连续的乘除时
 62                 if (tmpStack.isEmpty()) {
 63 
 64                     switch (opr.charAt(0)) {
 65                     case '*':
 66                         destStack.push(String.valueOf(Integer.parseInt(data1)
 67                                 * Integer.parseInt(data2)));
 68                         break;
 69 
 70                     case '/':
 71                         destStack.push(String.valueOf(Integer.parseInt(data1)
 72                                 / Integer.parseInt(data2)));
 73                         break;
 74                     }
 75 
 76                 } else {
 77 
 78                     destStack.push(calcSameLevel(tmpStack));
 79 
 80                 }
 81 
 82                 System.out.println("乘除计算后 destStack = " + destStack);
 83             } else {
 84                 // 如果不是乘除时直接放入目标栈中
 85                 destStack.push(elem);
 86                 System.out.println("非乘除直接放入 destStack = " + destStack);
 87             }
 88 
 89             if (srcStack.isEmpty()) {
 90                 break;
 91             }
 92             elem = (String) srcStack.pop();
 93         }
 94 
 95         // 如果没有加减时
 96         if (destStack.size() == 1) {
 97             return (String) destStack.pop();
 98         } else {
 99             // 后执行加减表式
100             return calcSameLevel(destStack);
101         }
102 
103     }
104 
105     /**
106      * 同级运算
107      * 
108      * @param destStack
109      * @return
110      */
111     private static String calcSameLevel(Stack destStack) {
112         String tmpResult = null;
113         String data1;
114         String opr;
115         String data2;
116 
117         while (!destStack.isEmpty()) {
118             if (tmpResult == null) {
119                 data1 = (String) destStack.pop();
120 
121                 opr = (String) destStack.pop();
122 
123                 data2 = (String) destStack.pop();
124 
125             } else {
126                 data1 = tmpResult;
127                 opr = (String) destStack.pop();
128                 data2 = (String) destStack.pop();
129             }
130             switch (opr.charAt(0)) {
131             case '+':
132                 tmpResult = String.valueOf(Integer.parseInt(data1)
133                         + Integer.parseInt(data2));
134                 break;
135 
136             case '-':
137                 tmpResult = String.valueOf(Integer.parseInt(data1)
138                         - Integer.parseInt(data2));
139                 break;
140             case '*':
141                 tmpResult = String.valueOf(Integer.parseInt(data1)
142                         * Integer.parseInt(data2));
143                 break;
144 
145             case '/':
146                 tmpResult = String.valueOf(Integer.parseInt(data1)
147                         / Integer.parseInt(data2));
148                 break;
149             }
150         }
151         System.out.println("同优先级运算结果=" + tmpResult);
152         return tmpResult;
153     }
154 
155     public static void main(String[] args) {
156         String str = "2*2+(10-2)/(101-50*2)*3-2+5";
157         // String str ="2*(3+2-1)";
158         List elementsList = parse(str);
159         System.out.println("组成算术表达式的各元素为=" + elementsList);
160 
161         // 存入整体算术表达式各元素,在放入过程中如果遇到括号则要先计算括号里的算术式后再把计算出的结果放入栈中
162         Stack srcStack = new Stack();
163         for (int i = 0; i < elementsList.size(); i++) {
164             String elem = (String) elementsList.get(i);
165             if (elem.equals(")")) {
166                 System.out.println("遇到右括号,准备计算括号里的算术式,srcStack = " + srcStack);
167                 srcStack.push(calcMix(srcStack));
168                 System.out.println("括号里的算术式计算完毕,srcStack = " + srcStack);
169             } else {
170                 // 如果不为右括号放入栈
171                 srcStack.push(elem);
172                 System.out.println("非右括号,直接入栈 srcStack = " + srcStack);
173             }
174         }
175         System.out.println(srcStack);
176         // 所有括号里表达式计算完后计算整体算术式
177         if (srcStack.size() > 1) {
178             System.out.println("结果为=" + calcMix(srcStack));
179         } else {
180             System.out.println("结果为=" + srcStack.pop());
181         }
182     }
183 }
Category.where(id: category_id).update_all(articles_count: articles_count)

组成算术表达式的各元素为=[2, *, 2, +, (, 10, -, 2, ), /, (, 101, -, 50, *, 2, ), *, 3, -, 2, +, 5]
非右括号,直接入栈 srcStack = [2]
非右括号,直接入栈 srcStack = [2, *]
非右括号,直接入栈 srcStack = [2, *, 2]
非右括号,直接入栈 srcStack = [2, *, 2, +]
非右括号,直接入栈 srcStack = [2, *, 2, +, (]
非右括号,直接入栈 srcStack = [2, *, 2, +, (, 10]
非右括号,直接入栈 srcStack = [2, *, 2, +, (, 10, -]
非右括号,直接入栈 srcStack = [2, *, 2, +, (, 10, -, 2]
遇到右括号,准备计算括号里的算术式,srcStack = [2, *, 2, +, (, 10, -, 2]
非乘除直接放入 destStack = [2]
非乘除直接放入 destStack = [2, -]
非乘除直接放入 destStack = [2, -, 10]
同优先级运算结果=8
括号里的算术式计算完毕,srcStack = [2, *, 2, +, 8]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *, 2]
遇到右括号,准备计算括号里的算术式,srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *, 2]
非乘除直接放入 destStack = [2]
乘除计算后 destStack = [100]
非乘除直接放入 destStack = [100, -]
非乘除直接放入 destStack = [100, -, 101]
同优先级运算结果=1
括号里的算术式计算完毕,srcStack = [2, *, 2, +, 8, /, 1]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2, +]
非右括号,直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2, +, 5]
[2, *, 2, +, 8, /, 1, *, 3, -, 2, +, 5]
非乘除直接放入 destStack = [5]
非乘除直接放入 destStack = [5, +]
非乘除直接放入 destStack = [5, +, 2]
非乘除直接放入 destStack = [5, +, 2, -]
非乘除直接放入 destStack = [5, +, 2, -, 3]
临时栈 tmpStack=[3, *, 1]
临时栈 tmpStack=[3, *, 1, /, 8]
同优先级运算结果=24
乘除计算后 destStack = [5, +, 2, -, 24]
非乘除直接放入 destStack = [5, +, 2, -, 24, +]
非乘除直接放入 destStack = [5, +, 2, -, 24, +, 2]
乘除计算后 destStack = [5, +, 2, -, 24, +, 4]
同优先级运算结果=31
结果为=31

-------------------------------- 作者在 2019-08-23 19:21:10 补充以下内容

也可以直接使用update_column

@category.update_column(articles_count: articles_count)