Regular Expression White Space

Question

With the following regular expression (^DOC)*[0-9] I can capture all numbers after the "DOC" sequence. However, by testing this text :

TEXT TEXT TEXT DOCUMENT:240010 24/09/2014

It returns me "24001024092014", the date comes along. The question is, how do I get the numerical sequence, and if I find a space, it doesn’t include it in the regex ? I would like to capture only the document number.

Follows java code:

public class Teste {

    public static void main(String args[]){

        String CAPTURAR_SOMENTE_NUMEROS_APOS_PALAVRA_DOC = "(^DOC)*\\d+ ";

        Pattern pattern = Pattern.compile(CAPTURAR_SOMENTE_NUMEROS_APOS_PALAVRA_DOC);

        Matcher matcher = pattern.matcher("TEXTO TEXTO TEXTO TEXTO DOCUMENTOLEGAL:240010 24/09/2014 ");

        while(matcher.find()){
            System.out.printf(matcher.group());
        }

    }
}

Answer 1

The method Matcher.find looks for occurrences of a regular expression in a string. That is, it returns any substring that matches the regex you are looking for. If you want to extract the number that is just ahead of a DOC, there are two ways: capture groups and lookarounds.

Capture Groups

The method of capture groups is the simplest, as demonstrated in the response of Rodrigo Rigotti: you establish the text you want to marry, and in parentheses you place the subtexts that interest you the most. Simple example:

DOCUMENTO:([0-9]+)
DOCUMENTO:(\d+)

This picks up the string DOCUMENTO: and any sequence of numbers that follows it, and nothing else. The sequence of numbers - being within a hood group - can be accessed through the method group(int):

matcher.find();
System.out.printf(matcher.group(0)); // Pega o primeiro (no caso, o único) grupo de captura

If you have any variance in the word DOCUMENTO - for example accepting both DOCUMENTO how much DOC - you can mark the suffix as optional (through the operator ?):

DOC(UMENTO)?:(\d+)

But note that in doing so, you have created a new capture group - which will be the zero group, and the numbers you want will be the one group. If you want to prevent the first group from being captured, you can use (?:regex) instead of (regex):

DOC(?:UMENTO)?:(\d+)

Finally, if you have other possible entries - as in your example, DOCUMENTOLEGAL - you can adjust the regex accordingly, or even accept any sequence of letters after DOC:

DOC\w*:(\d+)

Just be careful not to marry more than you want (\w accepts any letter, number or underscore; regex* accepts zero or more occurrences of regex).

Lookarounds

The lookarounds are parts of regex that are checked, but do not enter the final result. A Lookahead tries to marry stretches ahead while a lookbehind Try marrying parts back. Sometimes this technique is useful, but it is too complicated (and does not work equally in all implementations of regular expressions), so I suggest avoiding it when possible. By way of example, his expression would look like this:

(?<=DOCUMENTO:)\d+

That is, "take a sequence of numbers, but make sure that this sequence is preceded by DOCUMENTO: not including in marriage". The disadvantage of this technique is that it is not anything that can be placed in a lookbehing - in particular, many implementations require regex to have a fixed size. Which in your case is a problem as you need to check both for DOC how much for DOCUMENTO, etc....

Answer 2

A suggestion:

DOCUMENTO:(\d+)\s*(\d+)\/(\d+)\/(\d+)

Example of implementation:

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

public class RegexMatches
{
    public static void main(String args[]) {

      String line = "TEXTO TEXTO TEXTO TEXTO DOCUMENTO:240010 24/09/2014";
      String pattern = "DOCUMENTO:(\d+)\s*(\d+)\/(\d+)\/(\d+)";

      Pattern r = Pattern.compile(pattern);

      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println(m.group(0) + m.group(1) + m.group(2) + m.group(3));
      } else {
         System.out.println("Sem resultados.");
      }
   }
}

Answer 3

String[] vetor = texto.split((^DOC)*[0-9]\\S);  

The resulting vector will have two positions: vector[0]= 240010 and vector[1]= 24092014, just take the vector[0] that interests it.