在字符串中查找特定标记的最佳方法是什么（在Java中）？

我有一个带有标记的字符串，我需要使用Java查找它

例如

string=abcdefghijkl
期望输出。。
段[n]=开始、结束
段[1]=4,6
段[2]=10，10

正则表达式应该能很好地实现这一点

有关详细信息，请参阅JavaDoc

• java.langString.split（）
• java.util.regex包
• java.util.Scanner

---

注意：StringTokenizer不是您想要的，因为它围绕字符而不是字符串进行拆分-字符串delim是一个字符列表，其中任何一个都将被拆分。它适用于非常简单的情况，如明确的逗号分隔列表。

正则表达式应能很好地解决这一问题

有关详细信息，请参阅JavaDoc

• java.langString.split（）
• java.util.regex包
• java.util.Scanner

---

注意：StringTokenizer不是您想要的，因为它围绕字符而不是字符串进行拆分-字符串delim是一个字符列表，其中任何一个都将被拆分。它适用于非常简单的情况，如明确的逗号分隔列表。

当您想用特定字符串分隔字符串时，StringTokenizer将为您提供单独的标记。

---

或者您可以使用String中的split（）方法来获取单独的字符串。要获得不同的数组，您必须将正则表达式放入。

当您要用特定字符串分隔字符串时，StringTokenizer将为您提供单独的标记。

---

或者您可以使用String中的split（）方法来获取单独的字符串。要获得不同的数组，必须在其中放入正则表达式。

StringTokenizer将整个字符串作为参数，对于大字符串来说，这并不是一个好主意。 你也可以使用

---

您还需要了解。

StringTokenizer将整个字符串作为参数，对于大字符串来说这并不是一个好主意。 你也可以使用

---

您还需要了解。

鉴于您的示例，我想我会使用regex，尤其是我会了解Matcher提供的分组功能

汤姆

String inputString=“abcdefghijkl”；
String stringPattern=“（）（[a-zA-Z]+）（）”；
Pattern=Pattern.compile（stringPattern）；
Matcher Matcher=pattern.Matcher（inputString）；
if（matcher.matches（））{
字符串firstGroup=matcher.group（1）；
字符串secondGroup=matcher.group（2）；
字符串thirdGroup=matcher.group（3）；
}

举个例子，我想我会使用regex，特别是我会看看Matcher提供的分组功能

汤姆

String inputString=“abcdefghijkl”；
String stringPattern=“（）（[a-zA-Z]+）（）”；
Pattern=Pattern.compile（stringPattern）；
Matcher Matcher=pattern.Matcher（inputString）；
if（matcher.matches（））{
字符串firstGroup=matcher.group（1）；
字符串secondGroup=matcher.group（2）；
字符串thirdGroup=matcher.group（3）；
}

这有点“蛮力”，并做出了一些假设，但这是可行的

public class SegmentFinder
{

    public static void main(String[] args)
    {
        String string = "abc<B>def</B>ghi<B>j</B>kl";
        String startRegExp = "<B>";
        String endRegExp = "</B>";
        int segmentCounter = 0;
        int currentPos = 0;
        String[] array = string.split(startRegExp);
        for (int i = 0; i < array.length; i++)
        {           
            if (i > 0) // Ignore the first one
            {
                segmentCounter++;
                //this assumes that every start will have exactly one end
                String[] array2 = array[i].split(endRegExp);
                int elementLenght = array2[0].length();
                System.out.println("segment["+segmentCounter +"] = "+ (currentPos+1) +","+ (currentPos+elementLenght) );
                for(String s : array2)
                {
                    currentPos += s.length();  
                }
            }
            else
            {
                currentPos += array[i].length();                
            }
        }
    }
}

公共类分段查找器
{
公共静态void main（字符串[]args）
{
String String=“abcdefghijkl”；
字符串startRegExp=“”；
字符串endRegExp=“”；
int段计数器=0；
int currentPos=0；
String[]数组=String.split（startRegExp）；
for（int i=0；i0）//忽略第一个
{
分段计数器++；
//这假设每个起点都有一个终点
字符串[]array2=数组[i]。拆分（endRegExp）；
int-elementLenght=array2[0].length（）；
System.out.println（“段[“+段计数器+”]=”+（currentPos+1）+“，”+（currentPos+ElementLength））；
用于（字符串s:array2）
{
currentPos+=s.长度（）；
}
}
其他的
{
currentPos+=数组[i]。长度（）；
}
}
}
}

这有点“蛮力”，并做出了一些假设，但这是可行的

public class SegmentFinder
{

    public static void main(String[] args)
    {
        String string = "abc<B>def</B>ghi<B>j</B>kl";
        String startRegExp = "<B>";
        String endRegExp = "</B>";
        int segmentCounter = 0;
        int currentPos = 0;
        String[] array = string.split(startRegExp);
        for (int i = 0; i < array.length; i++)
        {           
            if (i > 0) // Ignore the first one
            {
                segmentCounter++;
                //this assumes that every start will have exactly one end
                String[] array2 = array[i].split(endRegExp);
                int elementLenght = array2[0].length();
                System.out.println("segment["+segmentCounter +"] = "+ (currentPos+1) +","+ (currentPos+elementLenght) );
                for(String s : array2)
                {
                    currentPos += s.length();  
                }
            }
            else
            {
                currentPos += array[i].length();                
            }
        }
    }
}

公共类分段查找器
{
公共静态void main（字符串[]args）
{
String String=“abcdefghijkl”；
字符串startRegExp=“”；
字符串endRegExp=“”；
int段计数器=0；
int currentPos=0；
String[]数组=String.split（startRegExp）；
for（int i=0；i0）//忽略第一个
{
分段计数器++；
//这假设每个起点都有一个终点
字符串[]array2=数组[i]。拆分（endRegExp）；
int-elementLenght=array2[0].length（）；
System.out.println（“段[“+段计数器+”]=”+（currentPos+1）+“，”+（currentPos+ElementLength））；
用于（字符串s:array2）
{
currentPos+=s.长度（）；
}
}
其他的
{
currentPos+=数组[i]。长度（）；
}
}
}
}

您的输入是否与您的示例相似，并且需要在特定标记之间获取文本？然后使用ApacheCommonsLang包（）在（您的字符串，“，”）之间创建一个简单的StringUtils.substringsBeween（您的字符串，“，”）来完成这项工作

---

如果您想要一个更通用的解决方案，针对不同的、可能是嵌套的标记，那么您可能需要查看一个解析器，它接受html输入并从中创建xml文档，例如NekoHTML、TagSoup、jTidy。然后，您可以在xml文档上使用XPath来访问内容。

您的输入是否与示例类似，并且需要在特定标记之间获取文本？然后使用ApacheCommonsLang包（）在（您的字符串，“，”）之间创建一个简单的StringUtils.substringsBeween（您的字符串，“，”）来完成这项工作

如果你想得到一个更一般的解决方案，那么你可以

public class SegmentFinder
{

    public static void main(String[] args)
    {
        String string = "abc<B>def</B>ghi<B>j</B>kl";
        String startRegExp = "<B>";
        String endRegExp = "</B>";
        int segmentCounter = 0;
        int currentPos = 0;
        String[] array = string.split(startRegExp);
        for (int i = 0; i < array.length; i++)
        {           
            if (i > 0) // Ignore the first one
            {
                segmentCounter++;
                //this assumes that every start will have exactly one end
                String[] array2 = array[i].split(endRegExp);
                int elementLenght = array2[0].length();
                System.out.println("segment["+segmentCounter +"] = "+ (currentPos+1) +","+ (currentPos+elementLenght) );
                for(String s : array2)
                {
                    currentPos += s.length();  
                }
            }
            else
            {
                currentPos += array[i].length();                
            }
        }
    }
}