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 -

  • Pattern Class- 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 seuscompile()métodos, que retornarão um objeto Pattern. Esses métodos aceitam uma expressão regular como o primeiro argumento.

  • Matcher Class- Um objeto Matcher é o mecanismo que interpreta o padrão e executa operações de correspondência em uma string de entrada. Como a classe Pattern, Matcher não define construtores públicos. Você obtém um objeto Matcher invocando omatcher() método em um objeto Pattern.

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

Capturar grupos é uma forma de tratar vários personagens 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 (cachorro) 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 correspondente. O método groupCount retorna umint mostrando o número de grupos de captura presentes no padrão de correspondência.

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

Example

O exemplo a seguir ilustra como encontrar uma string de dígitos da string alfanumérica fornecida -

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 -

Output

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 que lista toda a sintaxe de metacaracteres de expressão regular disponível em Java -

Subexpressão Fósforos
^ Corresponde ao início da linha.
$ Corresponde ao final da linha.
. Corresponde a qualquer caractere único, exceto nova linha. Usandom a 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.
\UMA Início de toda a corda.
\ z Fim de toda a string.
\ Z Fim de toda a string, exceto terminador de linha final permitido.
ré* Corresponde a 0 ou mais ocorrências da expressão anterior.
re + Corresponde a 1 ou mais do anterior.
ré? 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.
(ré) 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 não alfabéticos.
\ 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.
\UMA Corresponde ao início da string.
\ Z Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.
\ z Corresponde ao final da string.
\ G Corresponde ao ponto onde a última partida terminou.
\ n Referência anterior para capturar o número do grupo "n".
\ b Corresponde aos limites da palavra fora dos colchetes. Corresponde ao backspace (0x08) quando dentro dos colchetes.
\ B Corresponde aos limites sem palavras.
\ n, \ t, etc. Corresponde a novas linhas, retornos de carro, guias, etc.
\ Q Escape (aspas) de 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 -

Sr. Não. Método e Descrição
1

public int start()

Retorna o índice inicial da correspondência 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 o último caractere encontrado.
4

public int end(int group)

Retorna o deslocamento após o último caractere da subsequência capturada por um determinado grupo durante a operação de correspondência anterior.

Métodos de Estudo

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

Sr. Não. Método e Descrição
1

public boolean lookingAt()

Tenta combinar a sequência de entrada, começando no início da região, com o padrão.
2

public boolean find()

Tenta encontrar a próxima subsequência da sequência de entrada que corresponda ao padrão.
3

public boolean find(int start)

Redefine esse matcher e, em seguida, tenta encontrar a próxima subsequência da sequência de entrada que corresponde ao padrão, começando no índice especificado.
4

public boolean matches()

Tenta combinar toda a região com o padrão.

Métodos de Substituição

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

Sr. Não. Método e Descrição
1

public Matcher appendReplacement(StringBuffer sb, String replacement)

Implementa uma etapa não terminal de anexar e substituir.
2

public StringBuffer appendTail(StringBuffer sb)

Implementa uma etapa de anexar e substituir de terminal.
3

public String replaceAll(String replacement)

Substitui cada subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
4

public String replaceFirst(String replacement)

Substitui a primeira subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
5

public static String 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 literals 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 "gato" aparece na string de entrada -

Example

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 -

Output

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 meramente uma substring em uma palavra mais longa. Também fornece algumas informações úteis sobre onde na string de entrada a correspondência ocorreu.

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

As correspondências e métodos lookingAt

Os métodos match e lookingAt tentam combinar uma sequência de entrada com um padrão. A diferença, no entanto, é que as correspondências requerem que toda a sequência de entrada seja correspondida, enquanto que lookingAt não.

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

Example

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 -

Output

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 que explica a funcionalidade -

Example

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 -

Output

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 que explica a funcionalidade -

Example

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 -

Output

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

Sr. Não. Método e Descrição
1

public String getDescription()

Recupera a descrição do erro.
2

public int getIndex()

Recupera o índice de erro.
3

public String getPattern()

Recupera o padrão de expressão regular incorreto.
4

public String 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.