查找给定 String 中所有 String[] 的连续出现

Question

我在一个数组中有一对字符串来检查另一个字符串：

String[] validPair = "{"[BOLD]", "[/BOLD]" };
String toCheck = "Example [BOLD]bold long text[/BOLD] other example [BOLD]bold short[/BOLD]";

我需要检查标签的平衡，我知道如何检查一个字符串是否在另一个字符串中，以及如何使用字符串中的indexOf 和validPair 内容并保存引用来实现这一点，但是一种丑陋的方式，我不想重新发明轮子。

类似：

int lastIndex = 0;
while (lastIndex != -1) {
    int index = toCheck.findNextOccurrence(validPair, lastIndex); // here use indexOf
    System.out.println(index);
    lastIndex = index;
}

我在猜测是否有办法可以检查String[] validPair 中String[] validPair 中的任何字符串的nextOccurrence String toCheck？

一种Iterator 或Tokenizer，但不拆分字符串并仅给出array（或List 或任何其他Object）内容的出现次数。

或者：

OwnIterator ownIterator = new OwnIterator<String>(toCheck, validPair);
while (toCheck.hasNext()) {
    String next = toCheck.findNextOccurrence();
    System.out.println(next);
}

输出：

[BOLD]
[/BOLD]
[BOLD]
[/BOLD]

Answer 1

这是我想出的解决方案。它使用正则表达式数组分别搜索validPair 中的每个项目，然后将所有找到的事件合并到一个列表（及其迭代器）中

public class OwnIterator implements Iterator 
{
    private Iterator<Integer> occurrencesItr;

    public OwnIterator(String toCheck, String[] validPair) {
        // build regex to search for every item in validPair
        Matcher[] matchValidPair = new Matcher[validPair.length];
        for (int i = 0 ; i < validPair.length ; i++) {
            String regex = 
                    "(" +    // start capturing group
                    "\\Q" +  // quote entire input string so it is not interpreted as regex
                    validPair[i] +  // this is what we are looking for, duhh 
                    "\\E" +  // end quote
                    ")" ;    // end capturing group
            Pattern p = Pattern.compile(regex);
            matchValidPair[i] = p.matcher(toCheck);
        }
        // do the search, saving found occurrences in list
        List<Integer> occurrences = new ArrayList<>();
        for (int i = 0 ; i < matchValidPair.length ; i++) {
            while (matchValidPair[i].find()) {
                occurrences.add(matchValidPair[i].start(0)+1);  // +1 if you want index to start at 1 
            }
        }
        // sort the list 
        Collections.sort(occurrences);
        occurrencesItr = occurrences.iterator();
    }

    @Override
    public boolean hasNext()
    {
        return occurrencesItr.hasNext();
    }

    @Override
    public Object next()
    {
        return occurrencesItr.next();
    }
}

快速测试：

public static void main(String[] args)
{
    String[] validPair = {"[BOLD]", "[/BOLD]" };
    String toCheck = "Example [BOLD]bold long text[/BOLD] other example [BOLD]bold short[/BOLD]";
    OwnIterator itr = new OwnIterator(toCheck, validPair);
    while (itr.hasNext()) {
        System.out.println(itr.next());
    }
}

给出所需的输出：

9
29
51
67

编辑： 找到了一个更好的解决方案，只有一个正则表达式包含 validPair 中所有带有“或”条件的项目 (|)。那么你有 Matcher 自己的 find() 方法作为迭代器：

    String regex = "(";
    for (int i = 0 ; i < validPair.length ; i++) {
        regex += (i == 0 ? "" : "|") +  // add "or" after first item
                "\\Q" +  // quote entire input string so it is not interpreted as regex
                validPair[i] +  // this is what we are looking for, duhh 
                "\\E";  // end quote
    }
    regex += ")";
    System.out.println("using regex : " + regex);
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(toCheck);

    while (m.find()) {
        System.out.println(m.group(0));
    }

你得到输出

using regex : (\Q[BOLD]\E|\Q[/BOLD]\E)
[BOLD]
[/BOLD]
[BOLD]
[/BOLD]

Answer 2

你可以这样做：

int first = toCheck.indexOf(validPair[0]);
boolean ok = first > -1 && toCheck.indexOf(validPair[1], first) > 0;