java中用递归的写法处理字符串，你会吗？

如果你想循环解析一个字符串，一般你会怎么做，可能选择的是正则去处理字符串，那么我将教你用堆栈的形式将符号提取出来，进行处理，以下是全部的代码，大家可以CV下来自己跑一下(这个递归其实存在一定的问题，只是为了帮助大家更好的理解递归的含义，对字符串的处理最好不要用递归来做)

  如果有什么地方不理解的，可以留言或者评论

有一个问题，就是不能什么都用递归哦，下面整理几个递归调用的条件

• 大问题能拆分等价于小问题的循环重复（必须）
• 有控制条件（称为出口）来断开自我调用，或者继续自我调用，控制条件并不一定是简单的判断语句，可以有多种情况或者多个条件（必须）
• 一次自调用的结果，应该是下一次调用的初始值

/**
 * @des 一般最好不要用递归，用递归的条件如下（要想好在写）
 *      1.返回值必须是下次的调用值（如果是void则不需要）
 *      2.必须要有一个明确的结束条件
 *      3.递归过多导致栈溢出（栈帧里面套用栈帧，效率不高）
 * @author 719383495@qq.com
 * @date 2019/7/31 13:56
 */
package com.algorithm;

import org.apache.commons.collections.ArrayStack;

public class Recursive {

    private static StringBuffer sb = new StringBuffer();

    public static void main(String[] args) {

        String recursive = recursive("${}${{{}}}");
        System.out.println(recursive);
    }

    public static String recursive(String str) {

        char[] c = str.toCharArray();
        int len = c.length;
        boolean tag = false;
        int temp0 = 0;
        int temp1 = 0;
        ArrayStack stack = new ArrayStack();
        for (int i = 0; i < len; i++) {
            if (36 == c[i]) {
                tag = true;
                temp0 = i + 1;
            }
            if (tag == true) {
                if (123 == c[i]) {
                    stack.push(c[i]);
                }
                if (125 == c[i]) {
                    stack.pop();
                    temp1 = i;
                    if (stack.size() == 0) {
                        tag = false;
                        sb.append(String.valueOf(c, temp0, temp1 - temp0+1));
                        String newStr = String.valueOf(c, temp1 + 1, len - temp1 - 1);
                        if ("".equals(newStr)) {
                            return sb.toString();
                        } else {
                            return recursive(newStr);
                        }

                    }
                }

            }
        }
        return null;
    }

}