最近学习到后缀表达式,于是基于后缀表达式的思想,写了一个四则运算解释器,输入字符串类型的四则运算表达式,可以直接得到结果,支持括号嵌套. 
实现时主要考虑以下两点:

  • 字符串中运算符和数字分离
  • 运算符优先级
  • 括号的嵌套
  1. 运算符和数字分离:可以考虑用字符串数组存储
  2. 关于运算符优先级,最开始的想法是将乘除法看作一类,加减法看作一类,乘除法的优先级大于加减法,相同类型的运算符按照从左到右顺序依次计算.
  3. 括号的嵌套:由于括号内部本身也是表达式,因此可以使用递归处理,但重点在于括号的配对,由于使用递归,所以希望获取最大的嵌套单元.

具体实现:

首先实现运算符识别的代码,判断一个字符是否为运算符:

  1. public static boolean opjudge(char c) {
  2.         if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
  3.             return true;
  4.         else
  5.             return false;
  6.     }

然后实现字符串表达式转为字符串数组, 由于要求输入的字符串运算符和数字之间没有空格,所以直接拆分不方便,而且运算符和数字的数目不确定,因此先使用ArrayList存储,然后再转成字符串数组,主要方法是遍历字符串中每一个字符并判断是否为运算符,如果是运算符,则直接将运算符转为字符串加入ArrayList,如果不是,则从此位置继续查找到下一个运算符出现的位置,两个位置之间即为操作数,使用substring截取字符串存入Arraylist,具体实现如下:

  1. public static String[] convert(String s) {
  2.         ArrayList<String> arrayList = new ArrayList<>();
  3.         for (int i = 0; i < s.length(); i++) {
  4.             if (!opjudge(s.charAt(i))) {
  5.                 int j = i;
  6.                 while ((i < s.length()) && !opjudge(s.charAt(i)))
  7.                     i++;
  8.                 arrayList.add(s.substring(j, i));
  9.                 i--;
  10.             } else
  11.                 arrayList.add(String.valueOf(s.charAt(i)));
  12.         }
  13.  
  14.         return arrayList.toArray(new String[arrayList.size()]);
  15.  
  16.     }

然后对运算符进行分类和分级,加减法视作一类,乘除法视作一类,乘除法优先级高于加减法:

  1.  public static int opvalue(String s) {
  2.         switch (s) {
  3.         case "+":
  4.         case "-":
  5.             return 1;
  6.         case "*":
  7.         case "/":
  8.             return 2;
  9.         default:
  10.             return -1;
  11.         }
  12.  
  13.     }

运算符优先级的比较,左边大于右边则返回true,( 两个运算符相等返回false)

  1.  public static boolean opcompare(String s1, String s2) {
  2.         if (opvalue(s1) > opvalue(s2))
  3.             return true;
  4.         else {
  5.             return false;
  6.         }
  7.  
  8.     }

括号内字符串的获取: 
由于括号都是成对出现,要从左至右获取第一个最长的括号表达式,则从左至右遍历字符串时,当右括号 ‘)’ 出现的数目等于左括号’(’ 时,即为所求,此处使用计数器实现,返回的是字符串中从k位置(第k个元素，一个数字算一个元素 )开始第一个带完整括号的子串,比如输入bracketGet(“(8-(2+3))*2+(5+7)*3”,0),返回8-(2+3):

  1. public static String bracketGet(String s, int k) {
  2.         int m=0;
  3.         int i;
  4.         String[] arr=convert(s);
  5.         for(i=k;i<arr.length;i++){
  6.             if(arr[i].equals("(")){
  7.                 m++;
  8.                 continue;
  9.                 }
  10.             if(arr[i].equals(")")){
  11.                 m--;
  12.                 if(m==0)
  13.                     break;
  14.                 else
  15.                     continue;
  16.             }
  17.  
  18.         }
  19.         StringBuilder sb=new StringBuilder();
  20.         for(int j=k+1;j<i;j++){
  21.             sb.append(arr[j]);
  22.         }
  23.         return sb.toString();
  24.     }

以上都是需要用到的配件,下面将利用上面写好的函数实现四则运算字符串的解析和运算,基本思想是使用两个栈,一个存储数字,一个存储运算符,先考虑没有括号的简单情况: 
遍历字符串数组: 
1.当前元素为操作数时,入数字栈 
2.当前元素为运算符时:

  • 如果运算符栈为空,则入运算符栈
  • 如果运算符栈不空,则比较当前运算符和栈顶运算符优先级(按照之前定义的优先级,乘除大于加减,乘除相同,加减相同):如果当前运算符优先级大于栈顶运算符,则当前运算符入栈;反之,如果当前运算符优先级等于或小于栈顶运算符,则将栈顶运算符出栈,同时数字栈中出栈两个数字参与运算,结果压入数字栈中,然后当前运算符入栈;
  • 最后将运算符栈中所有元素依次出栈,数字栈中相应将数字出栈参与运算得到结果并压入栈中;
  • 最后返回数字栈中栈顶元素即为表达式结果.
  • 有括号时括号内的运算步骤同上,可以获取括号内部的字符串,使用递归计算; 
    代码如下:
    1. public static int caculate(String formula) {
    2.         String[] arr = convert(formula);
    3.         Stack<Integer> val = new Stack<>();
    4.         Stack<String> op = new Stack<>();
    5.  
    6.         for (int i = 0; i < arr.length; i++) {
    7.             if (arr[i].equals("(")) {
    8.                 val.push(caculate(bracketGet(formula, i)));//递归计算括号内部的值,并将该值入栈
    9.                 i = i + bracketGet(formula, i).length() + 1;//括号串所在的位置遍历过,i需要跳过该段
    10.             } else {
    11.                 if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    12.                     if (op.isEmpty())
    13.                         op.push(arr[i]);
    14.                     else if (opcompare(arr[i], op.lastElement())) {
    15.                         op.push(arr[i]);
    16.                     } else {
    17.  
    18.                         switch (op.pop()) {
    19.                         case "+":
    20.                             val.push(val.pop() + val.pop());
    21.                             break;
    22.                         case "-":
    23.                             int c = val.pop();
    24.                             int d = val.pop();
    25.                             val.push(d-c);//减法,pop的顺序从右至左,所以需要先取出元素
    26.                             break;
    27.                         case "*":
    28.                             val.push(val.pop() * val.pop());
    29.                             break;
    30.                         case "/":
    31.                             int a = val.pop();
    32.                             int b = val.pop();
    33.                             val.push(b / a);//同减法
    34.                             break;
    35.                         default:
    36.                             break;
    37.                         }
    38.                         op.push(arr[i]);
    39.                     }
    40.                 } else
    41.                     val.push(Integer.parseInt(arr[i]));
    42.             }
    43.         }
    44.         while (!op.isEmpty()) {
    45.             switch (op.pop()) {
    46.             case "+":
    47.                 val.push(val.pop() + val.pop());
    48.                 break;
    49.             case "-":
    50.                 int c = val.pop();
    51.                 int d = val.pop();
    52.                 val.push(d-c);
    53.                 break;
    54.             case "*":
    55.                 val.push(val.pop() * val.pop());
    56.                 break;
    57.             case "/":
    58.                 int a = val.pop();
    59.                 int b = val.pop();
    60.                 val.push(b / a);
    61.                 break;
    62.             default:
    63.                 break;
    64.             }
    65.         }
    66.  
    67.         return val.pop();
    68.     }
    69. System.out.println(caculate("(((8-(2+3))*2+(5+7)*3))"));
    70. 输出:42 正确

    以上实现是使用int类型,除法可能会不准确,改为double会准确

    后面又发现上面的实现方法仍然有冗余之处,下面是改进的代码,主要是优化了运算符的优先级,依次为 除法 乘法 减法 加法 依次降低, 遍历到运算符时,优先级高才入栈, 否则将栈中运算符出栈参与运算,直到栈空或 栈顶运算符优先级低于遍历到的运算符,才将该运算符入栈. 
    主要改动的是opjudge(),opcompare(), caculate()中少量改动,其余代码同上; 
    具体代码如下:

    1. public static int opvalue2(String s) {
    2.         switch (s) {
    3.         case "+":
    4.             return 1;
    5.         case "-":
    6.             return 2;
    7.         case "*":
    8.             return 3;
    9.         case "/":
    10.             return 4;
    11.         default:
    12.             return -1;
    13.         }
    14.     }
    1. public static boolean opcompare2(String s1, String s2) {
    2.         if (opvalue2(s1) >= opvalue2(s2))
    3.             return true;
    4.         else {
    5.             return false;
    6.         }
    7.     }
    1. public static double caculate2(String formula) {
    2.         String[] arr = convert(formula);
    3.         Stack<Double> val = new Stack<>();
    4.         Stack<String> op = new Stack<>();
    5.  
    6.         for (int i = 0; i < arr.length; i++) {
    7.             if (arr[i].equals("(")) {
    8.                 val.push(caculate2(bracketGet(formula, i)));
    9.                 i = i + bracketGet(formula, i).length() + 1;
    10.             } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    11.                         while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
    12.                             switch (op.pop()) {
    13.                             case "+":
    14.                                 val.push(val.pop() + val.pop());
    15.                                 continue;
    16.                             case "-":
    17.                                 double c = val.pop();
    18.                                 double d = val.pop();
    19.                                 val.push(d - c);
    20.                                 continue;
    21.                             case "*":
    22.                                 val.push(val.pop() * val.pop());
    23.                                 continue;
    24.                             case "/":
    25.                                 double a = val.pop();
    26.                                 double b = val.pop();
    27.                                 val.push(b / a);
    28.                                 continue;
    29.                             default:
    30.                                 break;
    31.                             }
    32.                         }
    33.                         op.push(arr[i]);
    34.                 }
    35.                 else
    36.                     val.push(Double.parseDouble(arr[i]));
    37.         }
    38.         while (!op.isEmpty()) {
    39.             switch (op.pop()) {
    40.             case "+":
    41.                 val.push(val.pop() + val.pop());
    42.                 break;
    43.             case "-":
    44.                 double c = val.pop();
    45.                 double d = val.pop();
    46.                 val.push(d - c);
    47.                 break;
    48.             case "*":
    49.                 val.push(val.pop() * val.pop());
    50.                 break;
    51.             case "/":
    52.                 double a = val.pop();
    53.                 double b = val.pop();
    54.                 val.push(b / a);
    55.                 break;
    56.             default:
    57.                 break;
    58.             }
    59.         }
    60.         return val.pop();
    61.     }

    运算实例:

    1. public static void main(String[] args) {
    2.         double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
    3.         System.out.println(a);
    4.         System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
    5.     }
    6. //output:
    7. -9.2
    8. -9.2

    至此,完成了四则运算字符串解释器,还有很多可以完善, 比如异常的处理,以及代码的简洁性,作为一个初学者,如果能被看到的话,希望多提建议:

    完整版代码如下:

    1. import java.util.ArrayList;
    2. import java.util.Stack;
    3.  
    4. public class Main {
    5.  
    6.     public static void main(String[] args) {
    7.         double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
    8.         System.out.println(a);
    9.         System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
    10.     }
    11.  
    12.     //对运算符优先级进一步排序  减法大于加法   除法大于乘法
    13.     public static double caculate2(String formula) {
    14.         String[] arr = convert(formula);
    15.         Stack<Double> val = new Stack<>();
    16.         Stack<String> op = new Stack<>();
    17.  
    18.         for (int i = 0; i < arr.length; i++) {
    19.             if (arr[i].equals("(")) {
    20.                 val.push(caculate2(bracketGet(formula, i)));
    21.                 i = i + bracketGet(formula, i).length() + 1;
    22.             } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
    23.                         while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
    24.                             switch (op.pop()) {
    25.                             case "+":
    26.                                 val.push(val.pop() + val.pop());
    27.                                 continue;
    28.                             case "-":
    29.                                 double c = val.pop();
    30.                                 double d = val.pop();
    31.                                 val.push(d - c);
    32.                                 continue;
    33.                             case "*":
    34.                                 val.push(val.pop() * val.pop());
    35.                                 continue;
    36.                             case "/":
    37.                                 double a = val.pop();
    38.                                 double b = val.pop();
    39.                                 val.push(b / a);
    40.                                 continue;
    41.                             default:
    42.                                 break;
    43.                             }
    44.                         }
    45.                         op.push(arr[i]);
    46.                 }
    47.                 else
    48.                     val.push(Double.parseDouble(arr[i]));
    49.         }
    50.         while (!op.isEmpty()) {
    51.             switch (op.pop()) {
    52.             case "+":
    53.                 val.push(val.pop() + val.pop());
    54.                 break;
    55.             case "-":
    56.                 double c = val.pop();
    57.                 double d = val.pop();
    58.                 val.push(d - c);
    59.                 break;
    60.             case "*":
    61.                 val.push(val.pop() * val.pop());
    62.                 break;
    63.             case "/":
    64.                 double a = val.pop();
    65.                 double b = val.pop();
    66.                 val.push(b / a);
    67.                 break;
    68.             default:
    69.                 break;
    70.             }
    71.         }
    72.         return val.pop();
    73.     }
    74.  
    75. public static String bracketGet(String s, int k) {
    76.         int m=0;
    77.         int i;
    78.         String[] arr=convert(s);
    79.         for(i=k;i<arr.length;i++){
    80.             if(arr[i].equals("(")){
    81.                 m++;
    82.                 continue;
    83.                 }
    84.             if(arr[i].equals(")")){
    85.                 m--;
    86.                 if(m==0)
    87.                     break;
    88.                 else
    89.                     continue;
    90.             }
    91.         }
    92.         StringBuilder sb=new StringBuilder();
    93.         for(int j=k+1;j<i;j++){
    94.             sb.append(arr[j]);
    95.         }
    96.         return sb.toString();
    97.     }
    98.  
    99. public static String[] convert(String s) {
    100.         ArrayList<String> arrayList = new ArrayList<>();
    101.         for (int i = 0; i < s.length(); i++) {
    102.             if (!opjudge(s.charAt(i))) {
    103.                 int j = i;
    104.                 while ((i < s.length()) && !opjudge(s.charAt(i)))
    105.                     i++;
    106.                 arrayList.add(s.substring(j, i));
    107.                 i--;
    108.             } else
    109.                 arrayList.add(String.valueOf(s.charAt(i)));
    110.         }
    111.         return arrayList.toArray(new String[arrayList.size()]);
    112.     }
    113.  
    114.     public static boolean opjudge(char c) {
    115.     if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
    116.         return true;
    117.     else
    118.         return false;
    119. }
    120.  
    121.     public static int opvalue2(String s) {
    122.         switch (s) {
    123.         case "+":
    124.             return 1;
    125.         case "-":
    126.             return 2;
    127.         case "*":
    128.             return 3;
    129.         case "/":
    130.             return 4;
    131.         default:
    132.             return -1;
    133.         }
    134.     }
    135.  
    136.     public static boolean opcompare2(String s1, String s2) {
    137.         if (opvalue2(s1) >= opvalue2(s2))
    138.             return true;
    139.         else {
    140.             return false;
    141.         }
    142.     }

最近学习到后缀表达式,于是基于后缀表达式的思想,写了一个四则运算解释器,输入字符串类型的四则运算表达式,可以直接得到结果,支持括号嵌套. 
实现时主要考虑以下两点:

  • 字符串中运算符和数字分离
  • 运算符优先级
  • 括号的嵌套
  1. 运算符和数字分离:可以考虑用字符串数组存储
  2. 关于运算符优先级,最开始的想法是将乘除法看作一类,加减法看作一类,乘除法的优先级大于加减法,相同类型的运算符按照从左到右顺序依次计算.
  3. 括号的嵌套:由于括号内部本身也是表达式,因此可以使用递归处理,但重点在于括号的配对,由于使用递归,所以希望获取最大的嵌套单元.

具体实现:

首先实现运算符识别的代码,判断一个字符是否为运算符:

  1. public static boolean opjudge(char c) {
  2.         if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
  3.             return true;
  4.         else
  5.             return false;
  6.     }

然后实现字符串表达式转为字符串数组, 由于要求输入的字符串运算符和数字之间没有空格,所以直接拆分不方便,而且运算符和数字的数目不确定,因此先使用ArrayList存储,然后再转成字符串数组,主要方法是遍历字符串中每一个字符并判断是否为运算符,如果是运算符,则直接将运算符转为字符串加入ArrayList,如果不是,则从此位置继续查找到下一个运算符出现的位置,两个位置之间即为操作数,使用substring截取字符串存入Arraylist,具体实现如下:

  1.     public static String[] convert(String s) {
  2.         ArrayList<String> arrayList = new ArrayList<>();
  3.         for (int i = 0; i < s.length(); i++) {
  4.             if (!opjudge(s.charAt(i))) {
  5.                 int j = i;
  6.                 while ((i < s.length()) && !opjudge(s.charAt(i)))
  7.                     i++;
  8.                 arrayList.add(s.substring(j, i));
  9.                 i--;
  10.             } else
  11.                 arrayList.add(String.valueOf(s.charAt(i)));
  12.         }
  14.         return arrayList.toArray(new String[arrayList.size()]);
  16.    :
  1.     public static void main(String[] args) {
  2.         double a=(1+2*(3.0/2)/(2+8)-(2*6.0)/(1+7))-(21+3*(5-2-(7*(4-3))));
  3.         System.out.println(a);
  4.         System.out.println(caculate2("(1+2*(3/2)/(2+8)-(2*6)/(1+7))-(21+3*(5-2-(7*(4-3))))"));
  5.     }
  6. //output:
  7. -9.2
  8. -9    }

  2.     //对运算符优先级进一步排序  减法大于加法   除法大于乘法
  3.     public static double caculate2(String formula) {
  4.         String[] arr = convert(formula);
  5.         Stack<Double> val = new Stack<>();
  6.         Stack<String> op = new Stack<>();
  8.         for (int i = 0; i < arr.length; i++) {
  9.             if (arr[i].equals("(")) {
  10.                 val.push(caculate2(bracketGet(formula, i)));
  11.                 i = i + bracketGet(formula, i).length() + 1;
  12.             } else if (arr[i].equals("+") || arr[i].equals("-") || arr[i].equals("*") || arr[i].equals("/")) {
  13.                         while (!op.isEmpty() && opcompare2(op.lastElement(), arr[i])) {
  14.                             switch (op.pop()) {
  15.                             case "+":
  16.                                 val.push(val.pop() + val.pop());
  17.                                 continue;
  18.                             case "-":
  19.                                 double c = val.pop();
  20.                                 double d = val.pop();
  21.                                 val.push(d - c);
  22.                                 continue;
  23.                             case "*":
  24.                                 val.push(val.pop() * val.pop());
  25.                                 continue;
  26.                             case "/":
  27.                                 double a = val.pop();
  28.                                 double b = val.pop();
  29.                                 val.push(b / a);
  30.                                 continue;
  31.                             default:
  32.                                 break;
  33.                             }
  34.                         }
  35.                         op.push(arr[i]);
  36.                 }
  37.                 else
  38.                     val.push(Double.parseDouble(arr[i]));
  40.         }
  41.         while (!op.isEmpty()) {
  42.             switch (op.pop()) {
  43.             case "+":
  44.                 val.push(val.pop() + val.pop());
  45.                 break;
  46.             case "-":
  47.                 double c = val.pop();
  48.                 double d = val.pop();
  49.                 val.push(d - c);
  50.                 break;
  51.             case "*":
  52.                 val.push(val.pop() * val.pop());
  53.                 break;
  54.             case "/":
  55.                 double a = val.pop();
  56.                 double b = val.pop();
  57.                 val.push(b / a);
  58.                 break;
  59.             default:
  60.                 break;
  61.             }
  62.         }
  64.         return val.pop();
  65.     }
  67. public static String bracketGet(String s, int k) {
  68.         int m=0;
  69.         int i;
  70.         String[] arr=convert(s);
  71.         for(i=k;i<arr.length;i++){
  72.             if(arr[i].equals("(")){
  73.                 m++;
  74.                 continue;
  75.                 }
  76.             if(arr[i].equals(")")){
  77.                 m--;
  78.                 if(m==0)
  79.                     break;
  80.                 else
  81.                     continue;
  82.             }
  84.         }
  85.         StringBuilder sb=new StringBuilder();
  86.         for(int j=k+1;j<i;j++){
  87.             sb.append(arr[j]);
  88.         }
  89.         return sb.toString();
  90.     }
  92. public static String[] convert(String s) {
  93.         ArrayList<String> arrayList = new ArrayList<>();
  94.         for (int i = 0; i < s.length(); i++) {
  95.             if (!opjudge(s.charAt(i))) {
  96.                 int j = i;
  97.                 while ((i < s.length()) && !opjudge(s.charAt(i)))
  98.                     i++;
  99.                 arrayList.add(s.substring(j, i));
  100.                 i--;
  101.             } else
  102.                 arrayList.add(String.valueOf(s.charAt(i)));
  103.         }
  105.         return arrayList.toArray(new String[arrayList.size()]);
  107.     }
  109.     public static boolean opjudge(char c) {
  110.     if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
  111.         return true;
  112.     else
  113.         return false;
  114. }
  116.     public static int opvalue2(String s) {
  117.         switch (s) {
  118.         case "+":
  119.             return 1;
  120.         case "-":
  121.             return 2;
  122.         case "*":
  123.             return 3;
  124.         case "/":
  125.             return 4;
  126.         default:
  127.             return -1;
  128.         }
  130.     }
  132.     public static boolean opcompare2(String s1, String s2) {
  133.         if (opvalue2(s1) >= opvalue2(s2))
  134.             return true;
  135.         else {
  136.             return false;
  137.         }
  139.

JAVA四则运算字符串解释器的更多相关文章

  1. Java常量字符串String理解

    Java常量字符串String理解 以前关于String的理解仅限于三点:1.String 是final类,不可继承2.String 类比较字符串相等时时不能用“ == ”,只能用  "eq ...

  2. Java String字符串/==和equals区别,str。toCharAt(),getBytes,indexOf过滤存在字符，trim()/String与StringBuffer多线程安全/StringBuilder单线程—— 14.0

    课程概要 String 字符串 String字符串常用方法 StringBuffer StringBuilder String字符串: 1.实例化String对象 直接赋值  String str=& ...

  3. java截取字符串中的数字

    java从字符串中提取数字 随便给你一个含有数字的字符串,比如: String s="eert343dfg56756dtry66fggg89dfgf"; 那我们如何把其中的数字提取 ...

  4. 三张图彻底了解Java中字符串的不变性

    转载: 三张图彻底了解Java中字符串的不变性 定义一个字符串 String s = "abcd"; s中保存了string对象的引用.下面的箭头可以理解为"存储他的引用 ...

  5. java中字符串的非空判断

    问题如下:在java 中 字符串为null 如何判断String str;if(str==null) ??str.equal("null") ?? 答:我觉得应该搞清楚字符串对象和 ...

  6. java中字符串String 转 int(转)

    java中字符串String 转 int String -> int s="12345"; int i; 第一种方法:i=Integer.parseInt(s); 第二种方法 ...

  7. Java：字符串类String的功能介绍

    在java中,字符串是一个比较常用的类,因为代码中基本上处理的很多数据都是字符串类型的,因此,掌握字符串类的具体用法显得很重要了. 它的主要功能有如下几种:获取.判断.转换.替换.切割.字串的获取.大 ...

  8. Java空字符串与null的区别和判断字符串是否为空的方法

    Java空字符串与null的区别: 1.类型null表示的是一个对象的值,而并不是一个字符串.例如声明一个对象的引用,String a = null ;""表示的是一个空字符串,也 ...

  9. android112 jni 把java的字符串转换成c的字符串，数组处理

    package com.itheima.charencode; import android.os.Bundle; import android.app.Activity; import androi ...

随机推荐

  1. scanf的一个问题（暂未解决）

    如下代码,没有按照预想的那样运行: int a; char b; printf("input a integer\n"); scanf("%d", &a ...

  2. TOP排行新闻列表。

    效果图: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3 ...

  3. C# mongoDB Driver 使用对象方式查询语法大全

    #region 查询方法 /// <summary> /// 获取单个对象 /// </summary> /// <typeparam name="T" ...

  4. ThreadLocal、Volatile、synchronized、Atomic

    前言 对于ThreadLocal.Volatile.synchronized.Atomic这四个关键字,我想一提及到大家肯定都想到的是解决在多线程并发环境下资源的共享问题,但是要细说每一个的特点.区别 ...

  5. Python divmod方法

    有95条数据 每十条存一页 all_item = 95 pager = 10 result = all_item.__divmod__(pager) print(result) (9{商},5{余数} ...

  6. BZOJ1787 [Ahoi2008]Meet 紧急集合 LCA

    欢迎访问~原文出处——博客园-zhouzhendong 去博客园看该题解 题目传送门 - BZOJ1787 题意概括 有一棵节点为n个(n≤500000)的树.接下来m次询问(m≤500000),每次 ...

  7. 8. 博客系统| 富文本编辑框和基于bs4模块防御xss攻击

    views.py @login_required def cn_backend(request): article_list = models.Article.objects.filter(user= ...

  8. MQ确认机制之事务机制----confirm串行

    一:介绍 1.说明原理 A:生产者将信道设置成confirm模式,一旦信道进到confirm模式,所有该信道上发布的消息都会被指派一个唯一的ID(从1开始). 一旦消息被投递到所有匹配的队列后,bro ...

  9. MXNet 中的 hybird_forward 的一个使用技巧

    from mxnet.gluon import nn from mxnet import nd class SliceLike(nn.HybridBlock): def __init__(self, ...

  10. 机器学习 支持向量机（SVM） 从理论到放弃，从代码到理解

    基本概念 支持向量机(support vector machines,SVM)是一种二分类模型,它的基本模型是定义在特征空间上的间隔最大的线性分类器.支持向量机还包括核技巧,这使它成为实质上的非线性分 ...