Java - Expressões Regulares

Java fornece o pacote java.util.regex para correspondência de padrões com expressões regulares. As expressões regulares Java são muito semelhantes à linguagem de programação Perl e muito fáceis de aprender.

Uma expressão regular é uma sequência especial de caracteres que ajuda a encontrar ou encontrar outras strings ou conjuntos de strings, usando uma sintaxe especializada mantida em um padrão. Eles podem ser usados ​​para pesquisar, editar ou manipular texto e dados.

O pacote java.util.regex consiste principalmente nas três classes a seguir -

• 
  Classe de padrão − Um objeto Pattern é uma representação compilada de uma expressão regular. A classe Pattern não fornece construtores públicos. Para criar um padrão, você deve primeiro invocar um de seus compile() estático público métodos, que então retornarão um objeto Pattern. Esses métodos aceitam uma expressão regular como o primeiro argumento.
  
• 
  Classe de correspondência − Um objeto Matcher é o mecanismo que interpreta o padrão e executa operações de correspondência em uma string de entrada. Assim como a classe Pattern, o Matcher não define construtores públicos. Você obtém um objeto Matcher invocando o matcher() método em um objeto Pattern.
  
• 
  Exceção de sintaxe de padrão − Um objeto PatternSyntaxException é uma exceção não verificada que indica um erro de sintaxe em um padrão de expressão regular.
  

Capturando grupos

A captura de grupos é uma maneira de tratar vários caracteres como uma única unidade. Eles são criados colocando os caracteres a serem agrupados dentro de um conjunto de parênteses. Por exemplo, a expressão regular (dog) cria um único grupo contendo as letras "d", "o" e "g".

Os grupos de captura são numerados contando seus parênteses de abertura da esquerda para a direita. Na expressão ((A)(B(C))), por exemplo, existem quatro desses grupos -

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

Para descobrir quantos grupos estão presentes na expressão, chame o método groupCount em um objeto de correspondência. O método groupCount retorna um int mostrando o número de grupos de captura presentes no padrão do matcher.

Há também um grupo especial, o grupo 0, que sempre representa a expressão inteira. Este grupo não está incluído no total informado por groupCount.

Exemplo

O exemplo a seguir ilustra como encontrar uma string de dígitos da string alfanumérica fornecida -
Demonstração ao vivo

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

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

Isso produzirá o seguinte resultado -

Saída

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Sintaxe de Expressão Regular

Aqui está a tabela listando toda a sintaxe de metacaractere de expressão regular disponível em Java −

Subexpressão	Correspondências
^	Corresponde ao início da linha.
$	Corresponde ao final da linha.
.	Corresponde a qualquer caractere único, exceto nova linha. Usando m opção permite que ele corresponda à nova linha também.
[...]	Corresponde a qualquer caractere único entre colchetes.
[^...]	Corresponde a qualquer caractere único que não esteja entre colchetes.
\A	Início de toda a string.
\z	Fim de toda a string.
\Z	Fim de toda a string, exceto o terminador de linha final permitido.
re*	Corresponde a 0 ou mais ocorrências da expressão anterior.
re+	Corresponde a 1 ou mais do item anterior.
re?	Corresponde a 0 ou 1 ocorrência da expressão anterior.
re{ n}	Corresponde exatamente ao número n de ocorrências da expressão anterior.
re{ n,}	Corresponde a n ou mais ocorrências da expressão anterior.
re{ n, m}	Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.
a| b	Corresponde a a ou b.
(re)	Agrupa expressões regulares e lembra o texto correspondente.
(?:re)	Agrupa expressões regulares sem lembrar o texto correspondente.
(?> re)	Corresponde ao padrão independente sem retrocesso.
\w	Corresponde aos caracteres da palavra.
\W	Corresponde aos caracteres que não são palavras.
\s	Corresponde ao espaço em branco. Equivalente a [\t\n\r\f].
\S	Corresponde ao não-espaço em branco.
\d	Corresponde aos dígitos. Equivalente a [0-9].
\D	Corresponde aos não dígitos.
\A	Corresponde ao início da string.
\Z	Corresponde ao final da string. Se existir uma nova linha, ela corresponderá imediatamente antes da nova linha.
\z	Corresponde ao final da string.
\G	Corresponde ao ponto em que a última partida terminou.
\n	Referência para capturar o número do grupo "n".
\b	Corresponde aos limites da palavra quando fora dos colchetes. Corresponde ao backspace (0x08) quando dentro dos colchetes.
\B	Corresponde aos limites de não palavras.
\n, \t, etc.	Corresponde a novas linhas, retornos de carro, tabulações, etc.
\Q	Escape (aspas) todos os caracteres até \E.
\E	Termina a citação iniciada com \Q.

Métodos da classe Matcher

Aqui está uma lista de métodos de instância úteis -

Métodos de índice

Os métodos de índice fornecem valores de índice úteis que mostram precisamente onde a correspondência foi encontrada na string de entrada -

Nº Sr.	Método e descrição
1	public int start() Retorna o índice inicial da partida anterior.
2	public int start(int group) Retorna o índice inicial da subsequência capturada pelo grupo fornecido durante a operação de correspondência anterior.
3	public int end() Retorna o deslocamento após a correspondência do último caractere.
4	public int end(int group) Retorna o deslocamento após o último caractere da subsequência capturada pelo grupo fornecido durante a operação de correspondência anterior.

Métodos de estudo

Os métodos de estudo revisam a string de entrada e retornam um booleano indicando se o padrão foi encontrado ou não −

Nº Sr.	Método e descrição
1	public boolean lookAt() Tenta corresponder a sequência de entrada, começando no início da região, com o padrão.
2	local booleano público() Tenta encontrar a próxima subsequência da sequência de entrada que corresponde ao padrão.
3	local booleano público(int start) Redefine esse correspondente e tenta localizar a próxima subsequência da sequência de entrada que corresponde ao padrão, começando no índice especificado.
4	correspondências booleanas públicas() Tenta fazer a correspondência de toda a região com o padrão.

Métodos de substituição

Os métodos de substituição são métodos úteis para substituir texto em uma string de entrada -

Nº Sr.	Método e descrição
1	public Matcher appendReplacement(StringBuffer sb, substituição de string) Implementa uma etapa de anexar e substituir não terminal.
2	public StringBuffer appendTail(StringBuffer sb) Implementa uma etapa de anexação e substituição do terminal.
3	public String replaceAll(Substituição de string) Substitui cada subsequência da sequência de entrada que corresponde ao padrão pela string de substituição fornecida.
4	Public String replaceFirst(Substituição de string) Substitui a primeira subsequência da sequência de entrada que corresponde ao padrão pela string de substituição fornecida.
5	String estática pública quoteReplacement(String s) Retorna uma String de substituição literal para a String especificada. Este método produz uma String que funcionará como uma substituição literal s no método appendReplacement da classe Matcher.

Os métodos de início e fim

A seguir está o exemplo que conta o número de vezes que a palavra "cat" aparece na string de entrada -

Exemplo
Demonstração ao vivo

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

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Isso produzirá o seguinte resultado -

Saída

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Você pode ver que este exemplo usa limites de palavras para garantir que as letras "c" "a" "t" não sejam apenas uma substring em uma palavra mais longa. Ele também fornece algumas informações úteis sobre onde na string de entrada ocorreu a correspondência.

O método start retorna o índice inicial da subsequência capturada pelo determinado grupo durante a operação de correspondência anterior, e o método final retorna o índice do último caractere correspondido, mais um.

As correspondências e os métodos lookAt

Os métodos matches e lookingAt tentam corresponder uma sequência de entrada a um padrão. A diferença, no entanto, é que matches requer que toda a sequência de entrada seja correspondida, enquanto lookAt não.

Ambos os métodos sempre começam no início da string de entrada. Aqui está o exemplo explicando a funcionalidade -

Exemplo
Demonstração ao vivo

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

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

Isso produzirá o seguinte resultado -

Saída

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

Os métodos replaceFirst e replaceAll

Os métodos replaceFirst e replaceAll substituem o texto que corresponde a uma determinada expressão regular. Como seus nomes indicam, replaceFirst substitui a primeira ocorrência e replaceAll substitui todas as ocorrências.

Aqui está o exemplo explicando a funcionalidade -

Exemplo
Demonstração ao vivo

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

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

Isso produzirá o seguinte resultado -

Saída

The cat says meow. All cats say meow.

Os métodos appendReplacement e appendTail

A classe Matcher também fornece os métodos appendReplacement e appendTail para substituição de texto.

Aqui está o exemplo explicando a funcionalidade -

Exemplo
Demonstração ao vivo

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

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Isso produzirá o seguinte resultado -

Saída

-foo-foo-foo-

Métodos de classe PatternSyntaxException

Uma PatternSyntaxException é uma exceção não verificada que indica um erro de sintaxe em um padrão de expressão regular. A classe PatternSyntaxException fornece os seguintes métodos para ajudá-lo a determinar o que deu errado -

Nº Sr.	Método e descrição
1	string pública getDescription() Recupera a descrição do erro.
2	public int getIndex() Recupera o índice de erro.
3	string pública getPattern() Recupera o padrão de expressão regular incorreto.
4	string pública getMessage() Retorna uma string de várias linhas contendo a descrição do erro de sintaxe e seu índice, o padrão de expressão regular incorreto e uma indicação visual do índice de erro dentro do padrão.