Java 如何获得所有具有相同模式的字符串

我有一个具有这种结构的xml文件

<expression>[Customer ].[Sales ].[L_MOIS]</expression><expression>cast_varchar([Customer ].[Sales ].[L_MOIS_ANNEE])
+ ' ' + 
cast_varchar([Customer ].[Sales ].[C_ANNEE])</expression></dataItem></selection><detailFilters><detailFilter><filterExpression>[Customer ].[Sales ].[DT_JOUR] <= getdate()</filterExpression></detailFilter></detailFilters></query><query name="RSmag"><source><model /></source><selection><dataItem aggregate="none" name="Code magasin"><expression>[Customer statistics].[Stores].[C_MAGASIN]</expression></dataItem><dataItem aggregate="none" name="Libellé magasin" sort="ascending"><expression>[Customer statistics].[Stores].[L_MAGASIN]</expression></dataItem></selection><detailFilters><detailFilter><filterExpression>[Customer statistics].[Stores].[C_DEPOT] <>'500'</filterExpression></detailFilter><detailFilter><filterExpression>[Customer statistics].[Stores].[C_MAGASIN] not in ('005120';'005130';'005140')</filterExpression></detailFilter></detailFilters>
</query><query name="CAdept_avec_metier_cumul"><source><model /></source><selection><dataItem aggregate="none" name="Cod Metier" rollupAggregate="none"><expression>[Customer ].[Articles].[COD_DPTG]</expression></dataItem><dataItem name="Nombre de tickets" rollupAggregate="total">
<expression>count(distinct [Customer ].[Sales ].[ID_TICKET])</expression></dataItem><dataItem name="Nombre de tickets non affecté" rollupAggregate="total"><expression>count(distinct 
(case 
when [Customer ].[Sales ].[C_AFFECTATION] <> 1  
then [Customer ].[Sales ].[ID_TICKET]
else null 
end)
)</expression>

---

将问题分为两部分：

1） 使用合适的XML解析器解析XML数据，以提取所需的文本

2） 对于提取的文本字段，使用正则表达式提取所需的子字符串

下面的示例使用SAX解析器（顺便说一下，我使用的是Java13）

假设我们有一个包含以下XML的文件：

<root>
<query name="RSmag">
  <source>
    <model />
  </source>
  <selection>
    <dataItem aggregate="none" name="Code magasin">
      <expression>
        [Customer ].[Sales ].[L_MOIS]
      </expression>
      <expression>
        cast_varchar([Customer ].[Sales ].[L_MOIS_ANNEE]) + ' ' + cast_varchar([Customer ].[Sales ].[C_ANNEE])
      </expression>
    </dataItem>
  </selection>
  <detailFilters>
    <detailFilter>
      <filterExpression>
        [Customer ].[Sales ].[DT_JOUR] &lt;= getdate()
      </filterExpression>
    </detailFilter>
  </detailFilters>
</query>
<query name="RSmag">
  <source>
    <model />
  </source>
  <selection>
    <dataItem aggregate="none" name="Code magasin">
      <expression>
        [Customer statistics].[Stores].[C_MAGASIN]
      </expression>
    </dataItem>
    <dataItem aggregate="none" name="Libellé magasin" sort="ascending">
      <expression>
        [Customer statistics].[Stores].[L_MAGASIN]
      </expression>
    </dataItem>
  </selection>
  <detailFilters>
    <detailFilter>
      <filterExpression>
        [Customer statistics].[Stores].[C_DEPOT] &lt;&gt; '500'
      </filterExpression>
    </detailFilter>
    <detailFilter>
      <filterExpression>
        [Customer statistics].[Stores].[C_MAGASIN] 
        not in ('005120';'005130';'005140')
      </filterExpression>
    </detailFilter>
  </detailFilters>
</query>
<query name="CAdept_avec_metier_cumul">
  <source>
    <model />
  </source>
  <selection>
    <dataItem aggregate="none" name="Cod Metier" rollupAggregate="none">
      <expression>
        [Customer ].[Articles].[COD_DPTG]
      </expression>
    </dataItem>
    <dataItem name="Nombre de tickets" rollupAggregate="total">
      <expression>
        count(distinct [Customer ].[Sales ].[ID_TICKET])
      </expression>
    </dataItem>
    <dataItem name="Nombre de tickets non affecté" rollupAggregate="total">
      <expression>count(distinct 
                  (case 
                   when [Customer ].[Sales ].[C_AFFECTATION] &lt;&gt; 1  
                   then [Customer ].[Sales ].[ID_TICKET]
                   else null 
                   end)
                  )
      </expression>
    </dataItem>
  </selection>
</query>
</root>

步骤2-应用正则表达式 对于这些字符串中的每一个，我们都使用正则表达式来查找所需的数据：

\[.*?\](\.\[.*?\])*

这将搜索一个开头“[”，直到下一个“]”，并对零个或多个由句点分隔的后续“[”和“]”字符串重复此操作

为了处理不需要的子匹配，我们只保留组0：

Matcher m = pattern.matcher(text);
while (m.find()) {
    System.out.println("*** Matches found  : " + m.group(0));
}

这给了我们以下12个结果：

[Customer ].[Sales ].[L_MOIS]
[Customer ].[Sales ].[L_MOIS_ANNEE]
[Customer ].[Sales ].[C_ANNEE]
[Customer ].[Sales ].[DT_JOUR]
[Customer statistics].[Stores].[C_MAGASIN]
[Customer statistics].[Stores].[L_MAGASIN]
[Customer statistics].[Stores].[C_DEPOT]
[Customer statistics].[Stores].[C_MAGASIN]
[Customer ].[Articles].[COD_DPTG]
[Customer ].[Sales ].[ID_TICKET]
[Customer ].[Sales ].[C_AFFECTATION]
[Customer ].[Sales ].[ID_TICKET]

全解

import javax.xml.parsers.SAXParser；
导入javax.xml.parsers.SAXParserFactory；
导入org.xml.sax.Attributes；
导入org.xml.sax.SAXException；
导入org.xml.sax.helpers.DefaultHandler；
导入java.util.Set；
导入java.util.HashSet；
导入java.util.regex.Pattern；
导入java.util.regex.Matcher；
使用SAX解析来自文件的公共类{
//查找带有
//可选“.”将项目串到一个组中。
Pattern=Pattern.compile（\\[.\\\]（\\.\\[.\.\\]]）*”；
公共void parseUsingSax（）{
试一试{
SAXParserFactory=SAXParserFactory.newInstance（）；
SAXParser SAXParser=factory.newSAXParser（）；
//我们将检查的标签（将跳过所有其他标签）：
Set watchedElements=new HashSet（）；
添加（“表达式”）；
watchedElements.add（“filterExpression”）；
DefaultHandler=新的DefaultHandler（）{
private boolean inement=false；
私人StringBuilder StringBuilder；
@凌驾
public void startElement（字符串uri、字符串localName、字符串name、，
属性）引发SAX异常{
if（watchedElements.contains（name））{
不合格=正确；
stringBuilder=新的stringBuilder（）；
}
}
@凌驾
公共无效字符（char[]缓冲区、int start、int length）引发异常{
if（非水泥）{
追加（缓冲区、开始、长度）；
}
}
@凌驾
public void endElement（字符串uri、字符串localName、，
字符串名称）引发异常{
if（watchedElements.contains（name））{
不合格=不合格；
String extractedText=formatString（stringBuilder.toString（））；
System.out.println（）；
System.out.println（“提取的XML文本：“+extractedText”）；
打印匹配（提取文本）；
}
}
};
parse（“C:/tmp/query_data.xml”，handler）；
}捕获（例外e）{
系统错误打印（e）；
}
}
私有字符串格式字符串（字符串文本）{
text=text.replaceAll（“\\r\\n |\\r |\\n”，”“）；//删除换行符
text=text.replaceAll（“*”，“”）；//折叠多个空格
return text.trim（）；//删除前导/尾随空格
}
私有void打印匹配（字符串文本）{
Matcher m=模式匹配器（文本）；
while（m.find（））{
System.out.println（“***找到匹配项：”+m.group（0））；
}
}
}

不要对xml文档使用正则表达式，请使用类似XPathShow的xml解析器来显示示例输入文件

Matcher m = pattern.matcher(text);
while (m.find()) {
    System.out.println("*** Matches found  : " + m.group(0));
}

[Customer ].[Sales ].[L_MOIS]
[Customer ].[Sales ].[L_MOIS_ANNEE]
[Customer ].[Sales ].[C_ANNEE]
[Customer ].[Sales ].[DT_JOUR]
[Customer statistics].[Stores].[C_MAGASIN]
[Customer statistics].[Stores].[L_MAGASIN]
[Customer statistics].[Stores].[C_DEPOT]
[Customer statistics].[Stores].[C_MAGASIN]
[Customer ].[Articles].[COD_DPTG]
[Customer ].[Sales ].[ID_TICKET]
[Customer ].[Sales ].[C_AFFECTATION]
[Customer ].[Sales ].[ID_TICKET]

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.Set;
import java.util.HashSet;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class ParseFromFileUsingSax {

    // Looks for an opening "[" followed by a closing "]" with an 
    // optional "." to string items together into one group.
    Pattern pattern = Pattern.compile("\\[.*?\\](\\.\\[.*?\\])*");

    public void parseUsingSax() {
        try {

            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();

            // the tags we will inspect (all others will be skipped):
            Set<String> watchedElements = new HashSet();
            watchedElements.add("expression");
            watchedElements.add("filterExpression");

            DefaultHandler handler = new DefaultHandler() {

                private boolean inElement = false;
                private StringBuilder stringBuilder;

                @Override
                public void startElement(String uri, String localName, String name,
                        Attributes attributes) throws SAXException {
                    if (watchedElements.contains(name)) {
                        inElement = true;
                        stringBuilder = new StringBuilder();
                    }
                }

                @Override
                public void characters(char[] buffer, int start, int length) throws SAXException {
                    if (inElement) {
                        stringBuilder.append(buffer, start, length);
                    }
                }

                @Override
                public void endElement(String uri, String localName,
                        String name) throws SAXException {
                    if (watchedElements.contains(name)) {
                        inElement = false;
                        String extractedText = formatString(stringBuilder.toString());
                        System.out.println();
                        System.out.println("Extracted XML text : " + extractedText);
                        printMatches(extractedText);
                    }
                }

            };

            saxParser.parse("C:/tmp/query_data.xml", handler);

        } catch (Exception e) {
            System.err.print(e);
        }

    }

    private String formatString(String text) {
        text = text.replaceAll("\\r\\n|\\r|\\n", " "); // remove newlines
        text = text.replaceAll("  *", " "); // collapse multiple spaces
        return text.trim(); // remove leading/trailing whitespace
    }

    private void printMatches(String text) {
        Matcher m = pattern.matcher(text);
        while (m.find()) {
            System.out.println("*** Matches found  : " + m.group(0));
        }
    }

}