How can I get all the strings that have the same pattern

I have an xml file that has this structure

<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>

I want to extract all the names of tab, in result I should have:
[Customer ].[Sales ].[C_ANNEE]
[Customer ].[Sales ].[DT_JOUR]

But now what I'm getting is:

Customer

Sales

C_ANNEE

File f = new File("");  
        BufferedReader in = new BufferedReader(
                new InputStreamReader(new FileInputStream(f), "UTF-8"));
        String str;
        while ((str = in.readLine()) != null) {

            Matcher m = Pattern.compile("\\[(.*?)\\]").matcher(str);
            while (m.find()) {
                listres.add(m.group(1));

            }
        }

Break the problem into two separate parts:

1. Parse the XML data using a suitable XML parser, to extract the text we want.

2. For the extracted text fields, use a regular expression to extract the required sub-strings.

The following example uses a SAX parser (I am using Java 13, by the way).

Assume we have a file containing the following 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] <= 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>
    </dataItem>
  </selection>
</query>
</root>

Note the following:

a) I made an educated guess to create a valid XML document, based on the question's sample data.

b) I escaped the < and > symbols in the text, by using < and >.

Step 1 - Parsing the Data

This solution uses SAX for parsing - there are plenty of alternatives.

The following will read each line of the input file, discarding any tags which are not <expression> or <filterExpression> tags. This set can be adjusted as needed (watchedElements).

The code collects the text inside each of these tags, and cleans it up by removing newlines, and extra whitespace.

This gives us a set of 10 text strings, like this:

[Customer ].[Sales ].[L_MOIS]
cast_varchar([Customer ].[Sales ].[L_MOIS_ANNEE]) + ' ' + cast_varchar([Customer ].[Sales ].[C_ANNEE])
[Customer ].[Sales ].[DT_JOUR] <= getdate()
[Customer statistics].[Stores].[C_MAGASIN]
[Customer statistics].[Stores].[L_MAGASIN]
[Customer statistics].[Stores].[C_DEPOT] <> '500'
[Customer statistics].[Stores].[C_MAGASIN] not in ('005120';'005130';'005140')
[Customer ].[Articles].[COD_DPTG]
count(distinct [Customer ].[Sales ].[ID_TICKET])
count(distinct (case when [Customer ].[Sales ].[C_AFFECTATION] <> 1 then [Customer ].[Sales ].[ID_TICKET] else null end) )

Step 2 - Applying the Regex

For each of these strings we use a regular expression to find the data we want:

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

This searches for an opening "[", through to the next "]", and it repeats this for zero or more subsequent "[" and "]" strings separated by a period.

To deal with unwanted sub-matches we only keep group zero:

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

This gives us the following 12 results:

[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]

Full Solution

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));
        }
    }

}