Java Regex - Guia rápido

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.

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.

Exemplo

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 -

Resultado

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

Introdução

o java.util.regex.MatchResultinterface representa o resultado de uma operação de correspondência. Essa interface contém métodos de consulta usados ​​para determinar os resultados de uma correspondência com uma expressão regular. Os limites de correspondência, grupos e limites de grupo podem ser vistos, mas não modificados por meio de um MatchResult.

Declaração de interface

A seguir está a declaração para java.util.regex.MatchResult interface -

public interface MatchResult

Métodos de interface

Sr. Não	Método e Descrição
1	pretender() Retorna o deslocamento após o último caractere encontrado.
2	int end (int group) Retorna o deslocamento após o último caractere da subsequência capturada por um determinado grupo durante esta partida.
3	Grupo de strings () Retorna a subsequência de entrada correspondida pela correspondência anterior.
4	Grupo de strings (grupo interno) Retorna a subsequência de entrada capturada por um determinado grupo durante a operação de correspondência anterior.
5	int groupCount () Retorna o número de grupos de captura neste padrão de resultado de correspondência.
6	int start () Retorna o índice inicial da correspondência.
7	início interno (grupo interno) Retorna o índice inicial da subsequência capturada pelo grupo fornecido durante esta partida.

Introdução

o java.util.regex.Pattern classe representa uma representação compilada de uma expressão regular.

Declaração de classe

A seguir está a declaração para java.util.regex.Pattern classe -

public final class Pattern
   extends Object
      implements Serializable

Campo

A seguir estão os campos para java.util.regex.Duration classe -

• static int CANON_EQ - Ativa a equivalência canônica.

• static int CASE_INSENSITIVE - Ativa a correspondência sem distinção entre maiúsculas e minúsculas.

• static int COMMENTS - Permite espaços em branco e comentários no padrão.

• static int DOTALL - Ativa o modo dotall.

• static int LITERAL - Ativa a análise literal do padrão.

• static int MULTILINE - Ativa o modo multilinha.

• static int UNICODE_CASE - Ativa a dobradura de maiúsculas com reconhecimento de Unicode.

• static int UNICODE_CHARACTER_CLASS - Ativa a versão Unicode de classes de caracteres predefinidas e classes de caracteres POSIX.

• static int UNIX_LINES - Ativa o modo de linhas Unix.

Métodos de aula

Sr. Não	Método e Descrição
1	compilação de padrão estático (String regex) Compila a expressão regular fornecida em um padrão.
2	compilação de padrão estático (String regex, sinalizadores int) Compila a expressão regular fornecida em um padrão com os sinalizadores fornecidos.
3	sinalizadores int () Retorna os sinalizadores de correspondência desse padrão.
4	Matcher matcher (entrada CharSequence) Cria um matcher que corresponderá à entrada fornecida com este padrão.
5	correspondências booleanas estáticas (String regex, entrada CharSequence) Compila a expressão regular fornecida e tenta combinar a entrada fornecida com ela.
6	Padrão de string () Retorna a expressão regular a partir da qual este padrão foi compilado.
7	Citação de String estática (String s) Retorna uma String de padrão literal para a String especificada.
8	String [] split (entrada CharSequence) Divide a sequência de entrada fornecida em torno das correspondências desse padrão.
9	String [] split (entrada CharSequence, limite interno) Divide a sequência de entrada fornecida em torno das correspondências desse padrão.
10	String toString () Retorna a representação de string deste padrão.

Métodos herdados

Esta classe herda métodos das seguintes classes -

• Java.lang.Object

Introdução

o java.util.regex.Matcher classe atua como um mecanismo que executa operações de correspondência em uma sequência de caracteres, interpretando um padrão.

Declaração de classe

A seguir está a declaração para java.util.regex.Matcher classe -

public final class Matcher
   extends Object
      implements MatchResult

Métodos de aula

Sr. Não	Método e Descrição
1	Matcher appendReplacement (StringBuffer sb, substituição de string) Implementa uma etapa não terminal de anexar e substituir.
2	StringBuffer appendTail (StringBuffer sb) Implementa uma etapa de anexar e substituir de terminal.
3	pretender() Retorna o deslocamento após o último caractere encontrado.
4	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.
5	boolean find () Tenta encontrar a próxima subsequência da sequência de entrada que corresponda ao padrão.
6	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.
7	Grupo de strings () Retorna a subsequência de entrada capturada por um determinado grupo durante a operação de correspondência anterior.
8	Grupo de strings (nome da string) Retorna a subseqüência de entrada capturada pelo grupo de captura nomeado durante a operação de correspondência anterior.
9	int groupCount () Retorna o número de grupos de captura neste padrão de correspondência.
10	boolean hasAnchoringBounds () Consulta a ancoragem dos limites da região para este matcher.
11	boolean hasTransparentBounds () Consulta a transparência dos limites da região para este matcher.
12	hitEnd boolean () Retorna verdadeiro se o final da entrada foi atingido pelo mecanismo de pesquisa na última operação de correspondência realizada por este matcher.
13	boolean lookingAt () Tenta combinar a sequência de entrada, começando no início da região, com o padrão.
14	correspondências booleanas () Tenta combinar toda a região com o padrão.
15	Padrão padrão () Retorna o padrão interpretado por este matcher.
16	static String quoteReplacement (String s) Retorna uma string de substituição literal para a String especificada.
17	Região do Matcher (int start, int end) Define os limites da região deste matcher.
18	int regionEnd () Informa o índice final (exclusivo) da região deste matcher.
19	int regionStart () Informa o índice inicial da região deste matcher.
20	String replaceAll (substituição de string) Substitui cada subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
21	String replaceFirst (substituição de string) Substitui a primeira subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
22	boolean requireEnd () Retorna verdadeiro se mais entradas puderem transformar uma correspondência positiva em negativa.
23	Reinicialização do Matcher () Reinicia este matcher.
24	Reinicialização do Matcher (entrada CharSequence) Reinicia este matcher com uma nova sequência de entrada.
25	int start () Retorna o índice inicial da correspondência anterior.
26	início interno (grupo interno) Retorna o índice inicial da subsequência capturada pelo grupo fornecido durante a operação de correspondência anterior.
27	MatchResult toMatchResult () Retorna o estado de correspondência deste matcher como MatchResult.
28	String toString () Retorna a representação de string deste matcher.
29	Matcher useAnchoringBounds (boolean b) Define a ancoragem dos limites da região para este matcher.
30	Matcher usePattern (padrão newPattern) Altera o padrão que este Matcher usa para encontrar correspondências.
31	Matcher useTransparentBounds (boolean b) Define a transparência dos limites da região para este matcher.

Métodos herdados

Esta classe herda métodos das seguintes classes -

• Java.lang.Object

Introdução

o java.util.regex.PatternSyntaxException classe representa uma exceção não verificada lançada para indicar um erro de sintaxe em um padrão de expressão regular.

Declaração de classe

A seguir está a declaração para java.util.regex.PatternSyntaxException classe -

public class PatternSyntaxException
   extends IllegalArgumentException

Construtores

Sr. Não	Método e Descrição
1	PatternSyntaxException(String desc, String regex, int index) Constrói uma nova instância desta classe.

Métodos de aula

Sr. Não	Método e Descrição
1	String getDescription() Recupera a descrição do erro.
2	int getIndex() Recupera o índice de erro.
3	String getMessage() Retorna uma string multilinha 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.
4	String getPattern() Recupera o padrão de expressão regular incorreto.

Métodos herdados

Esta classe herda métodos das seguintes classes -

• Java.lang.Throwable
• Java.lang.Object

Exemplo

O exemplo a seguir mostra o uso dos métodos da classe java.util.regex.Pattern.PatternSyntaxException.

package com.tutorialspoint;

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

public class PatternSyntaxExceptionDemo {
   private static String REGEX = "[";
   private static String INPUT = "The dog says meow " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);
         
         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT); 
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

Vamos compilar e executar o programa acima, isso produzirá o seguinte resultado -

PatternSyntaxException: 
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

A seguir estão vários exemplos de caracteres correspondentes usando expressões regulares em java.

Sr. Não	Construir e combinar
1	x O personagem x
2	\\ O caractere barra invertida
3	\ 0n O caractere com valor octal 0n (0 ≤ n ≤ 7)
4	\ 0nn O caractere com valor octal 0nn (0 ≤ n ≤ 7)
5	\ 0mnn O caractere com valor octal 0mnn (0 ≤ m ≤ 3, 0 ≤ n ≤ 7)
6	\ xhh O caractere com valor hexadecimal 0xhh
7	\ uhhhh O caractere com valor hexadecimal 0xhhhh
8	\ t O caractere de tabulação ('\ u0009')
9	\ n O caractere de nova linha (alimentação de linha) ('\ u000A')
10	\ r O caractere de retorno de carro ('\ u000D')
11	\ f O caractere de avanço de formulário ('\ u000C')

A seguir estão vários exemplos de classes de caracteres correspondentes usando expressões regulares em java.

Sr. Não	Construir e combinar
1	[abc] a, b ou c (classe simples).
2	[^ abc] Qualquer caractere, exceto a, b ou c (negação).
3	[a-zA-Z] a a z ou A a Z, inclusive (intervalo).
4	[ad [mp]] a a d, ou m a p: [a-dm-p] (união).
5	[az && [def]] d, e ou f (interseção).
6	[az && [^ bc]] a a z, exceto para b e c: [ad-z] (subtração)
7	[az && [^ mp]] a a z, e não m a p: [a-lq-z] (subtração).

A seguir estão vários exemplos de correspondência de classes de caracteres predefinidas usando expressões regulares em java.

Sr. Não	Construir e combinar
1	. Qualquer caractere (pode ou não corresponder aos terminadores de linha).
2	\ d Um dígito: [0-9].
3	\ D Um não dígito: [^ 0-9].
4	\ s Um caractere de espaço em branco: [\ t \ n \ x0B \ f \ r]
5	\ S Um caractere diferente de espaço em branco: [^ \ s].
6	\W Um caractere de palavra: [a-zA-Z_0-9].
7	\W Um caractere diferente de palavra: [^ \ w]

A seguir estão vários exemplos de correspondência de classes de caracteres POSIX usando expressões regulares em java.

Sr. Não	Construir e combinar
1	\ p {inferior} Um caractere alfabético minúsculo: [az].
2	\ p {superior} Um caractere alfabético maiúsculo: [AZ].
3	\ p {ASCII} Todos ASCII: [\ x00- \ x7F].
4	\ p {Alpha} Um caractere alfabético: [\ p {Inferior} \ p {Superior}].
5	\ p {dígito} Um dígito decimal: [0-9].
6	\ p {Alnum} Um caractere alfanumérico: [\ p {Alpha} \ p {Digit}].
7	\ p {Punct} Pontuação: um de! "# $% & '() * +, -. / :; <=>? @ [\] ^ _> {|} <.
8	\ p {gráfico} Um caractere visível: [\ p {Alnum} \ p {Punct}].
9	\ p {Imprimir} Um caractere imprimível: [\ p {Gráfico} \ x20].
10	\ p {em branco} Um espaço ou uma guia: [\ t].
11	\ p {XDigit} Um dígito hexadecimal: [0-9a-fA-F].
12	\ p {espaço} Um caractere de espaço em branco: [\ t \ n \ x0B \ f \ r].

A seguir estão vários exemplos de correspondência de classes de caracteres JAVA usando expressões regulares em java.

Sr. Não	Construir e combinar
1	\ p {javaLowerCase} Equivalente a java.lang.Character.isLowerCase ().
2	\ p {javaUpperCase} Equivalente a java.lang.Character.isUpperCase ().
3	\ p {javaWhitespace} Equivalente a java.lang.Character.isWhitespace ().
4	\ p {javaMirrored} Equivalente a java.lang.Character.isMirrored ().

A seguir estão vários exemplos de correspondência de classes de caracteres Unicode usando expressões regulares em java.

Sr. Não	Construir e combinar
1	\ p {IsLatin} Um personagem de escrita latina.
2	\ p {InGreek} Um personagem do bloco grego.
3	\ p {Lu} Uma letra maiúscula.
4	\ p {IsAlfabético} Um caractere alfabético (propriedade binária).
5	\ p {Sc} Um símbolo de moeda.
6	\ P {InGreek} Qualquer personagem, exceto um no bloco grego.
7	[\ p {L} && [^ \ p {Lu}]] Qualquer letra, exceto maiúsculas.

A seguir estão vários exemplos de Boundary Matchers usando expressões regulares em java.

Sr. Não	Construir e combinar
1	^ O início de uma linha.
2	$ O fim de uma linha.
3	\ b Um limite de palavra.
4	\ B Um limite sem palavras.
5	\UMA O início da entrada.
6	\ G O final da partida anterior.
7	\ Z O fim da entrada, mas para o terminador final, se houver.
8	\ z O fim da entrada.

Um quantificador ganancioso indica ao mecanismo de pesquisa para pesquisar a string inteira e verificar se ela corresponde ao regexp fornecido. A seguir estão vários exemplos de Quantificadores Greedy usando expressão regular em java.

Sr. Não	Construir e combinar
1	X? X, uma vez ou não.
2	X * X, zero ou mais vezes
3	X + X, uma ou mais vezes.
4	X {n} X, exatamente n vezes.
5	X {n,} X, pelo menos n vezes.
6	X {n, m} X, pelo menos n, mas não mais do que m vezes

Um quantificador relutante indica que o mecanismo de busca deve começar com o menor pedaço possível da string. Uma vez encontrada a correspondência, o motor continua; caso contrário, adiciona um caractere à seção da string que está sendo verificada e pesquisa isso, e assim por diante. Este processo segue até encontrar uma correspondência ou toda a string se esgotar. A seguir estão vários exemplos de Quantificadores Relutantes usando expressão regular em java.

Sr. Não	Construir e combinar
1	X ?? X, uma vez ou não.
2	X *? X, zero ou mais vezes
3	X +? X, uma ou mais vezes.
4	X {n}? X, exatamente n vezes.
5	X {n,}? X, pelo menos n vezes.
6	X {n, m}? X, pelo menos n, mas não mais do que m vezes

Um quantificador possessivo é semelhante ao quantificador ganancioso. Indica que o motor deve ligar verificando toda a string. É diferente no sentido se não funcionar, se a correspondência falhou e não há como voltar atrás. A seguir estão vários exemplos de Quantificadores possessivos usando expressão regular em java.

Sr. Não	Construir e combinar
1	X? + X, uma vez ou não.
2	X * + X, zero ou mais vezes
3	X ++ X, uma ou mais vezes.
4	X {n} + X, exatamente n vezes.
5	X {n,} + X, pelo menos n vezes.
6	X {n, m} + X, pelo menos n, mas não mais do que m vezes

A seguir estão vários exemplos de operadores lógicos usando expressões regulares em java.

Sr. Não	Construir e combinar
1	XY X seguido por Y.
2	X | Y X ou Y.

Impressão