Expressões regulares Java

Expressões regulares definem padrões de strings.

Expressões regulares podem ser usadas para pesquisar, editar ou manipular texto.

As expressões regulares não estão limitadas a um idioma, mas existem diferenças sutis em cada idioma.

As expressões regulares Java são mais semelhantes às do Perl.

O pacote java.util.regex inclui principalmente as três classes a seguir:

• Classe padrão:

  O objeto padrão é uma representação compilada de uma expressão regular. A classe padrão não possui construtor público. Para criar um objeto Pattern, você deve primeiro chamar seu método de compilação estático público, que retorna um objeto Pattern. Este método aceita uma expressão regular como primeiro parâmetro.

• Classe de correspondência:

  O objeto Matcher é um mecanismo que interpreta e combina strings de entrada. Assim como a classe Pattern, Matcher não possui construtor público. Você precisa chamar o método matcher do objeto Pattern para obter um objeto Matcher.

• PatternSyntaxException:

  PatternSyntaxException é uma classe de exceção não obrigatória que representa um erro de sintaxe em um padrão de expressão regular.

Capturando grupo

A captura de grupos é uma forma de tratar vários caracteres como uma única unidade, criada agrupando caracteres entre parênteses.

Por exemplo, a expressão regular (cachorro) cria um único grupo contendo “d”, “o” e “g”.

Os grupos de captura são numerados contando seus colchetes de abertura da esquerda para a direita. Por exemplo, na expressão ((A)(B(C))), existem quatro desses grupos:

• ((ABC)))

• (UM)

• (B(C))

• (C)

Você pode verificar quantos grupos uma expressão possui chamando o método groupCount do objeto correspondente. O método groupCount retorna um valor int, indicando que o objeto correspondente possui atualmente vários grupos de captura.

Existe também um grupo especial (grupo 0) que sempre representa a expressão inteira. O grupo não está incluído no valor de retorno de groupCount.

Exemplo

O exemplo a seguir mostra como encontrar uma sequência de dígitos de uma determinada sequência:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

classe pública RegexMatches
{
public static void main(String args[]){

// Pesquisa a string de acordo com o padrão especificado String line = "Este pedido foi feito para QT3000! OK?";
Padrão de string = "(.*)(\d+)(.*)";

//Criar objeto Padrão Pattern r = Pattern.compile(pattern);

// Agora cria o objeto matcher Matcher m = r.matcher(line);
if (m.find()) {
System.out.println("Valor encontrado: " + m.group(0) );
System.out.println("Valor encontrado: " + m.group(1) );
System.out.println("Valor encontrado: " + m.group(2) );
} outro {
System.out.println("SEM CORRESPONDÊNCIA");
}
}
}

Os resultados de compilação e execução do exemplo acima são os seguintes:

 Valor encontrado: Este pedido foi feito para QT3000, OK?
Valor encontrado: Este pedido foi feito para QT300
Valor encontrado: 0

Sintaxe de expressão regular

Métodos da classe Matcher

Método de índice

O método index fornece valores de índice úteis que indicam exatamente onde a correspondência é encontrada na string de entrada:

métodos de pesquisa

O método de pesquisa examina a string de entrada e retorna um valor booleano indicando se o padrão foi encontrado:

método de substituição

O método de substituição é um método para substituir texto na string de entrada:

métodos de início e fim

Aqui está um exemplo de contagem do número de ocorrências da palavra "gato" em uma string de entrada:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

classe pública RegexMatches
{
private static final String REGEX = "\bcat\b";
String final estático privado INPUT =
"gato gato gato gato gato";

public static void main(String args[]){
Padrão p = Padrão.compile(REGEX);
Matcher m = p.matcher(INPUT); // Obtém o objeto matcher int count = 0;

enquanto(m.find()) {
contar++;
System.out.println("Número correspondente "+contagem);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}

Os resultados de compilação e execução do exemplo acima são os seguintes:

 Jogo número 1
início(): 0
fim(): 3
Jogo número 2
início(): 4
fim(): 7
Jogo número 3
início(): 8
fim(): 11
Jogo número 4
início(): 19
fim(): 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 de uma palavra mais longa. Ele também fornece algumas informações úteis sobre onde ocorreu a correspondência na string de entrada.

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 método end adiciona um ao índice do último caractere correspondido.

correspondências e métodos LookingAt

Os métodos matches e LookingAt são usados ​​para tentar corresponder a um padrão de sequência de entrada. A diferença entre eles é que matches requer que toda a sequência corresponda, enquanto o lookAt não.

Esses dois métodos são frequentemente usados ​​no início da string de entrada.

Usamos o seguinte exemplo para explicar esta função:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

classe pública RegexMatches
{
final estático privado String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
padrão estático privado;
matcher estático privado;

public static void main(String args[]){
padrão = Padrão.compile(REGEX);
matcher = padrão.matcher(INPUT);

System.out.println("REGEX atual é: "+REGEX);
System.out.println("ENTRADA atual é: "+ENTRADA);

System.out.println("olhandoAt(): "+matcher.olhandoAt());
System.out.println("correspondências(): "+correspondência.correspondências());
}
}

Os resultados de compilação e execução do exemplo acima são os seguintes:

 REGEX atual é: foo
A ENTRADA atual é: fooooooooooooooooo
olhandoAt(): verdadeiro
correspondências(): falso

Métodos replaceFirst e replaceAll

Os métodos replaceFirst e replaceAll são usados ​​para substituir o texto que corresponde a uma expressão regular. A diferença é que replaceFirst substitui a primeira correspondência e replaceAll substitui todas as correspondências.

O exemplo a seguir explica essa funcionalidade:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

classe pública RegexMatches
{
private static String REGEX = "cachorro";
private static String INPUT = "O cachorro diz miau." +
"Todos os cachorros dizem miau.";
string estática privada REPLACE = "gato";

public static void main(String[] args) {
Padrão p = Padrão.compile(REGEX);
//obtém um objeto correspondente
Correspondente m = p.correspondente(INPUT);
ENTRADA = m.replaceAll(REPLACE);
System.out.println(ENTRADA);
}
}

Os resultados de compilação e execução do exemplo acima são os seguintes:

 O gato diz miau. Todos os gatos dizem miau.

MétodosappReplacement e AppendTail

A classe Matcher também fornece métodosappendReplacement eappendTail para substituição de texto:

Veja o exemplo a seguir para explicar essa funcionalidade:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

classe pública RegexMatches
{
string estática privada REGEX = "a*b";
String estática privada INPUT = "aabfooaabfooabfoob";
String estática privada REPLACE = "-";
public static void main(String[] args) {
Padrão p = Padrão.compile(REGEX);
// Obtém o objeto correspondente Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
enquanto(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

Os resultados de compilação e execução do exemplo acima são os seguintes:

 -foo-foo-foo-

Métodos da classe PatternSyntaxException

PatternSyntaxException é uma classe de exceção não forçada que indica um erro de sintaxe em um padrão de expressão regular.

A classe PatternSyntaxException fornece os seguintes métodos para nos ajudar a ver quais erros ocorreram.