分离自定义标记'；在java中使用正则表达式的内容

我需要一段代码，它将获取Java字符串中由标记包围的所有值，如果标记的名称与一系列关键字匹配，则将它们作为字符串数组返回。对于创建的每个标记，这些标记都只是由“”包围的普通文本词和由“”包围的结束标记

读入文本的示例-

  <name>stuff<name/>
  <locations>example of text<locations/>
  <storybattles>more text somehow<storybattles/>
  <maincharacter>characters n stuff <maincharacter/>
//continues on with random tag text values

优选用例-

String inputText="pretend there are tags in here";
//Please pretend I added several keywordsd to the keywords list
ArrayList<String> keywords=new ArrayList<String>(); 
String[] allTheAnswers=kindStackOverflowMentorMethod(inputText,keywords);

String inputText=“假装这里有标签”；
//请假装我在关键字列表中添加了几个关键字
ArrayList关键字=新建ArrayList（）；
字符串[]allTheAnswers=KindstackOverflowMentor方法（输入文本，关键字）；

---

虽然我对正则表达式的了解有限，但我可以自己做到这一点，我只是在退缩，因为我知道这可以做得更好。如果你对你使用的正则表达式的每一部分都做了解释（或者是聪明人想出的任何解决方案），那么我会给你加分

下面是一个我将如何做的工作示例：

private static final String DATA = "<name>stuff<name/>\n" +
        "  <locations>example of text<locations/>\n" +
        "  <storybattles>more text somehow<storybattles/>\n" +
        "  <maincharacter>characters n stuff <maincharacter/>";

private static final List<String> KEYWORDS = Arrays.asList(
        new String[]{"name", "locations"});

private static final String PATTERN = "<%1$s>(.+?)<%1$s/>";

public static void main(String[] args) {

    List<String> strs = new ArrayList<>();
    for (String keyword : KEYWORDS) {
        String tempPattern = String.format(PATTERN, keyword);
        Pattern pattern = Pattern.compile(tempPattern);
        Matcher matcher = pattern.matcher(DATA);

        while(matcher.find()){
            strs.add(matcher.group(1));
        }
    }
}

private static final String DATA=“stuff\n”+
“文本示例\n”+
“更多文本\n”+
“人物和东西”；
私有静态最终列表关键字=Arrays.asList(
新字符串[]{“名称”，“位置”}）；
私有静态最终字符串模式=“（.+？）”；
公共静态void main（字符串[]args）{
List strs=new ArrayList（）；
for（字符串关键字：关键字）{
String tempPattern=String.format（模式，关键字）；
Pattern=Pattern.compile（tempPattern）；
Matcher Matcher=pattern.Matcher（数据）；
while（matcher.find（））{
标准添加（匹配器组（1））；
}
}
}

---

以下是一个我将如何做到这一点的工作示例：

private static final String DATA = "<name>stuff<name/>\n" +
        "  <locations>example of text<locations/>\n" +
        "  <storybattles>more text somehow<storybattles/>\n" +
        "  <maincharacter>characters n stuff <maincharacter/>";

private static final List<String> KEYWORDS = Arrays.asList(
        new String[]{"name", "locations"});

private static final String PATTERN = "<%1$s>(.+?)<%1$s/>";

public static void main(String[] args) {

    List<String> strs = new ArrayList<>();
    for (String keyword : KEYWORDS) {
        String tempPattern = String.format(PATTERN, keyword);
        Pattern pattern = Pattern.compile(tempPattern);
        Matcher matcher = pattern.matcher(DATA);

        while(matcher.find()){
            strs.add(matcher.group(1));
        }
    }
}

private static final String DATA=“stuff\n”+
“文本示例\n”+
“更多文本\n”+
“人物和东西”；
私有静态最终列表关键字=Arrays.asList(
新字符串[]{“名称”，“位置”}）；
私有静态最终字符串模式=“（.+？）”；
公共静态void main（字符串[]args）{
List strs=new ArrayList（）；
for（字符串关键字：关键字）{
String tempPattern=String.format（模式，关键字）；
Pattern=Pattern.compile（tempPattern）；
Matcher Matcher=pattern.Matcher（数据）；
while（matcher.find（））{
标准添加（匹配器组（1））；
}
}
}

---

你在找这个吗

import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public static void main(String[] args) {

    String inputText=" <name>stuff<name/>\n"+
        " <locations>example of text<locations/>\n"+
        " <storybattles>more text somehow<storybattles/>\n"+
        " <maincharacter>characters n stuff <maincharacter/>";

    //Please pretend I added several keywordsd to the keywords list
    ArrayList<String> keywords=new ArrayList<>(); 
    keywords.add("locations");
    keywords.add("maincharacter");

    //Call the function
    ArrayList<String> allTheAnswers=kindStackOverflowMentorMethod(inputText,keywords);

}

public static ArrayList<String> kindStackOverflowMentorMethod(String inputText, ArrayList<String> keywords){
    ArrayList<String> values=new ArrayList<>();
    Matcher m = Pattern.compile("<([a-z][a-z0-9]*)>(.*?)<(?:\\1)\\/>").matcher(inputText);
    while (m.find()){
        if (keywords.indexOf(m.group(1)) > -1)  {
            values.add(m.group(2));            
        }
    }
    return values;
}

import java.util.ArrayList；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共静态void main（字符串[]args）{
字符串inputText=“stuff\n”+
“文本示例\n”+
“更多文本\n”+
“人物和东西”；
//请假装我在关键字列表中添加了几个关键字
ArrayList关键字=新建ArrayList（）；
关键词.添加（“位置”）；
关键词.添加（“主要字符”）；
//调用函数
ArrayList allTheAnswers=kindstackoverflowmentor方法（输入文本，关键字）；
}
公共静态ArrayList KindstackOverflowMethod（字符串输入文本，ArrayList关键字）{
ArrayList值=新的ArrayList（）；
Matcher m=Pattern.compile（（.*）.Matcher（inputText）；
while（m.find（））{
if（关键字.indexOf（m.group（1））>-1）{
添加（m组（2））；
}
}
返回值；
}

正则表达式解释

<                   # match < literally
([a-z][a-z0-9]*)    # first capturing group - match TAG name
                      should start with a letter, followed by
                      0 or more letters or numbers
>                   # match > literally 
(.*?)               # 2nd capturing group - match content surrounded by TAGs
                      non-greedy match
<                   # match < literally
(?:\1)              # non-capturing group - match previous matched TAG name
\/>                 # match /> literally

<#匹配<字面意思
（[a-z][a-z0-9]*）#第一捕获组-匹配标签名称
应该以字母开头，然后是
0个或多个字母或数字
>#匹配>字面意思
（.*）#第二捕获组-匹配标记包围的内容
非贪婪匹配
<#匹配<字面意思
（？：\1）#非捕获组-匹配以前匹配的标记名
\/>#按字面意思匹配/>

你在找这个吗

import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public static void main(String[] args) {

    String inputText=" <name>stuff<name/>\n"+
        " <locations>example of text<locations/>\n"+
        " <storybattles>more text somehow<storybattles/>\n"+
        " <maincharacter>characters n stuff <maincharacter/>";

    //Please pretend I added several keywordsd to the keywords list
    ArrayList<String> keywords=new ArrayList<>(); 
    keywords.add("locations");
    keywords.add("maincharacter");

    //Call the function
    ArrayList<String> allTheAnswers=kindStackOverflowMentorMethod(inputText,keywords);

}

public static ArrayList<String> kindStackOverflowMentorMethod(String inputText, ArrayList<String> keywords){
    ArrayList<String> values=new ArrayList<>();
    Matcher m = Pattern.compile("<([a-z][a-z0-9]*)>(.*?)<(?:\\1)\\/>").matcher(inputText);
    while (m.find()){
        if (keywords.indexOf(m.group(1)) > -1)  {
            values.add(m.group(2));            
        }
    }
    return values;
}

import java.util.ArrayList；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共静态void main（字符串[]args）{
字符串inputText=“stuff\n”+
“文本示例\n”+
“更多文本\n”+
“人物和东西”；
//请假装我在关键字列表中添加了几个关键字
ArrayList关键字=新建ArrayList（）；
关键词.添加（“位置”）；
关键词.添加（“主要字符”）；
//调用函数
ArrayList allTheAnswers=kindstackoverflowmentor方法（输入文本，关键字）；
}
公共静态ArrayList KindstackOverflowMethod（字符串输入文本，ArrayList关键字）{
ArrayList值=新的ArrayList（）；
Matcher m=Pattern.compile（（.*）.Matcher（inputText）；
while（m.find（））{
if（关键字.indexOf（m.group（1））>-1）{
添加（m组（2））；
}
}
返回值；
}

正则表达式解释

<                   # match < literally
([a-z][a-z0-9]*)    # first capturing group - match TAG name
                      should start with a letter, followed by
                      0 or more letters or numbers
>                   # match > literally 
(.*?)               # 2nd capturing group - match content surrounded by TAGs
                      non-greedy match
<                   # match < literally
(?:\1)              # non-capturing group - match previous matched TAG name
\/>                 # match /> literally

<#匹配<字面意思
（[a-z][a-z0-9]*）#第一捕获组-匹配标签名称
应该以字母开头，然后是
0个或多个字母或数字
>#匹配>字面意思
（.*）#第二捕获组-匹配标记包围的内容
非贪婪匹配
<#匹配<字面意思
（？：\1）#非捕获组-匹配以前匹配的标记名
\/>#按字面意思匹配/>

非常感谢您！它的工作原理与预期一样，现在您能告诉我“%1$”和“s”在“”之间是如何工作的吗？该值是

String.format（）

的占位符，它不是正则表达式的一部分。在构建Pattern对象之前，我将该值更改为类似“name”的文本字符串，因此正则表达式变成

（.+？）

。关键字列表上的每次迭代都会将正则表达式更改为

之间的当前关键字。非常感谢！它的工作原理与预期一样，现在您能告诉我“%1$”和“s”在“”之间是如何工作的吗？