java截取第n对括号内的字符

[假痴不癫]

假设一个字符串中的括号都是成对的，请编写一个算法，将从左数第n对括号内的子串取出并返回。
例如(ad(d(d(adb)de)d)d)，从左数第n=3对括号内取子串，返回d(adb)de

[rencht]

String test = "(ad(d(d(adb)de)d)d)";
int n = 3;
for (int i = 0; i < n; i++) {
    int first = test.indexOf("(");
    int last = test.lastIndexOf(")");
    test = test.substring(first + 1, last);
}
System.out.println(test);

都是基础的字符串的方法

[huoer_gf]

假如n=2： 从左边数第二个左括号，记录其下标a，逆序遍历字符串同样寻找第二个右括号，记录其下标b。最后用substring截取截取a+1到b的字符串不就行了。 不过有时要考虑输入的字符串是否符合要求。

[huoer_gf]

引用 1 楼 rencht 的回复:

String test = "(ad(d(d(adb)de)d)d)";
int n = 3;
for (int i = 0; i < n; i++) {
    int first = test.indexOf("(");
    int last = test.lastIndexOf(")");
    test = test.substring(first + 1, last);
}
System.out.println(test);

都是基础的字符串的方法

我刚看时你还没回答，呵呵，基本和我说的思想一致！

[awenhao]

从左往右，设变量0，假如寻3，遇到（+1，如果是3，设置开始位置，遇到）-1，如果结果为3，设置结束位置，则停止

[awenhao]

我的方法 可以处理(a(j)(((d((gh)f))c)b)(i))

[shine333]

引用 5 楼 awenhao 的回复:

我的方法 可以处理(a(j)(((d((gh)f))c)b)(i))

+1

[shine333]

而且，任何时候，都不能出现负数，负数代表右括号多了。最后，计时器应该=0，否则就是左括号多了

[树成]

这是个栈运用的字符串解析算法，遇到(压栈，遇到)出栈，如果出现出栈而栈内无出栈对象，说明)过多，如果字符串到结尾，栈数不为0，说明(过多。至于索引，则可以以栈的大小来表示，或者干脆吧解析索引压入栈。

[oh_Maxy]

这段代码看看可符合要求。

import java.util.Scanner;
import java.util.Stack;

public class GetBracket
{

    //左、右括号常量
    private static final char LEFTBRACKET = '(';
    private static final char RIGHTBRACKET = ')';

    //第N对括号
    private static final int TARGETNUM = 3;

    public static void main(String[] args)
    {
        //键盘输入字符串
        System.out.print("请输入待测试的字符串：");
        Scanner sc = new Scanner(System.in);
        String testStr = sc.nextLine();

        //不为空，则进行处理，截取字符串
        if (null == testStr || testStr.length() <= 0)
        {
            System.out.println("输入的字符串为空。");
            return;
        }

        //转换为数组处理
        char[] cArr = testStr.toCharArray();
        //校验括号匹配性以及是否达到目标数
        if (!isAllowed(cArr))
        {
            return;
        }
        
        //截取括号中的字符串
        String targetStr = getStrFromBracket(cArr);
        if (null != targetStr)
        {
            System.out.println("截取目标括号中的字符串内容为：" + targetStr);
        }
    }

    /**
     * 入参的字符串括号要匹配，个数要超过TARGETNUM值
     */
    private static boolean isAllowed(char[] arr)
    {
        //若长度小于TARGETNUM，则括号数不够
        if (null == arr || arr.length < TARGETNUM)
        {
            System.out.println("入参字符串不合法！");
            return false;
        }

        //左括号计数器
        int counter = 0;
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < arr.length; i++)
        {
            char k = arr[i];
            switch (k)
            {
                //左括号，计数器+1
                case LEFTBRACKET:
                {
                    counter++;
                    stack.add(k);
                    break;
                }
                    //右括号，找出相应的左括号出栈
                case RIGHTBRACKET:
                {
                    if (stack.isEmpty())
                    {
                        System.out.println("入参字符串不合法！");
                        return false;
                    }
                    stack.pop();
                    break;
                }
                default:
            }
        }

        //若匹配括号数少于目标值或者括号不匹配
        if (counter < TARGETNUM || !stack.isEmpty())
        {
            System.out.println("入参字符串不合法！");
            return false;
        }
        return true;
    }

    /**
     * 从合法的字符串数组中，找到指定的字符串
     * @param cArr
     * @return 
     * @see
     */
    private static String getStrFromBracket(char[] cArr)
    {
        //左右下标初始化
        //int left = 0;
        //int right = 0;

        //成对括号计数器
        int counter = 0;

        int i = 0;
        //找到第N个左括号
        for (; i < cArr.length && counter < TARGETNUM; i++)
        {
            if (LEFTBRACKET == cArr[i])
            {
                counter++;
            }
        }

        //从目标左括号开始截取字符串
        int leftNum = 0;
        StringBuilder sb = new StringBuilder();
        outer: for (; i < cArr.length; i++)
        {
            if (cArr[i] == RIGHTBRACKET)
            {
                //左右括号数匹配了
                --leftNum;
                if (leftNum < 0)
                {
                    break outer;
                }
            }
            else if (cArr[i] == LEFTBRACKET)
            {
                //多余的左括号也要加入到String中，这里不需要break操作
                ++leftNum;
            }
            sb.append(cArr[i]);
        }
        return sb.toString();
    }
}