Expressão Regular em Java – Exemplo de Regex em Java

Bem-vindo ao Expressão Regular em Java. Também é chamado de Regex em Java. Quando comecei a programar, expressão regular em java era um pesadelo para mim. Este tutorial tem como objetivo ajudá-lo a dominar Expressão Regular em Java. Eu também voltarei aqui para refrescar minha aprendizagem de Java Regex.

Expressão Regular em Java

A expressão regular em java define um padrão para uma String. Expressão Regular pode ser usada para buscar, editar ou manipular texto. Uma expressão regular não é específica de linguagem, mas difere ligeiramente para cada linguagem. Expressão Regular em Java é mais semelhante ao Perl. As classes Java Regex estão presentes no pacote java.util.regex que contém três classes:

1. Padrão: O objeto Pattern é a versão compilada da expressão regular. A classe Pattern não possui nenhum construtor público e usamos seu método estático público compile para criar o objeto padrão passando o argumento de expressão regular.
2. Correspondente: Correspondente é o objeto do motor de regex Java que corresponde ao padrão de String de entrada com o objeto de padrão criado. A classe Correspondente não possui nenhum construtor público, e obtemos um objeto Correspondente usando o método correspondente do objeto de padrão que recebe a String de entrada como argumento. Em seguida, usamos o método corresponde que retorna um resultado booleano com base em se a String de entrada corresponde ou não ao padrão regex.
3. Exceção de Sintaxe de Padrão: Exceção de Sintaxe de Padrão é lançada se a sintaxe da expressão regular não estiver correta.

Vamos dar uma olhada em um exemplo de programa Java Regex.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// má expressão regular
		pattern = Pattern.compile("*xx*");

	}

}

Ao executarmos este exemplo de programa Java regex, obtemos a seguinte saída.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Visto que a expressão regular em Java gira em torno da classe String, a classe String foi estendida no Java 1.4 para fornecer um método corresponde que realiza a correspondência de padrões regex. Internamente, ele usa as classes de regex Java Padrão e Correspondente para processamento, mas obviamente reduz as linhas de código. A classe Padrão também contém o método corresponde, que recebe regex e String de entrada como argumento e retorna um resultado booleano após a correspondência. Portanto, o código abaixo funciona bem para corresponder a uma String de entrada a uma expressão regular em Java.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Então, se sua exigência é apenas verificar se a String de entrada corresponde ao padrão, você deve economizar tempo e linhas de código usando o método simples de correspondência de Strings. Você deve usar as classes Pattern e Matcher apenas quando precisar manipular a String de entrada ou precisar reutilizar o padrão. Observe que o padrão definido por regex é aplicado na String da esquerda para a direita e, uma vez que um caractere de origem é usado em uma correspondência, ele não pode ser reutilizado. Por exemplo, a regex “121” corresponderá a “31212142121” apenas duas vezes como “_121____121”.

Expressão Regular em Java – símbolos de correspondência comuns

Metacaracteres em Regex Java

Temos alguns metacaracteres em regex Java, são como códigos abreviados para padrões de correspondência comuns.

Há duas maneiras de usar metacaracteres como caracteres comuns em expressões regulares.

1. Anteceda o metacaractere com uma barra invertida (\).
2. Mantenha o metacaractere dentro de \Q (que inicia a citação) e \E (que a encerra).

Expressão Regular em Java – Quantificadores

Quantificadores em Regex Java especificam o número de ocorrências de um caractere para corresponder.

Quantificadores em Regex Java podem ser usados com classes de caracteres e grupos de captura também. Por exemplo, [abc]+ significa – a, b ou c – uma ou mais vezes. (abc)+ significa o grupo “abc” uma ou mais vezes. Vamos discutir sobre Grupo de Captura agora.

Expressão Regular em Java – Grupos de Captura

Grupos de captura em Expressões Regulares Java são usados para tratar múltiplos caracteres como uma única unidade. Você pode criar um grupo usando (). A porção da String de entrada que corresponde ao grupo de captura é salva na memória e pode ser recuperada usando Retroreferência. Você pode usar o método matcher.groupCount para descobrir o número de grupos de captura em um padrão regex java. Por exemplo, ((a)(bc)) contém 3 grupos de captura – ((a)(bc)), (a) e (bc). Você pode usar Retroreferência na expressão regular com uma barra invertida (\) e depois o número do grupo a ser recuperado. Grupos de captura e Retroreferências podem ser confusos, então vamos entender isso com um exemplo.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

No primeiro exemplo, em tempo de execução, o primeiro grupo de captura é (\w\d), que avalia para “a2” quando combinado com a String de entrada “a2a2” e é salvo na memória. Então, \1 refere-se a “a2” e, portanto, retorna verdadeiro. Por causa da mesma razão, a segunda afirmação imprime falso. Tente entender esse cenário para as afirmações 3 e 4 por si mesmo. 🙂 Agora vamos examinar alguns métodos importantes das classes Pattern e Matcher.

1. Podemos criar um objeto Pattern com flags. Por exemplo, Pattern.CASE_INSENSITIVE permite correspondência sem diferenciação de maiúsculas e minúsculas.
2. A classe Pattern também fornece o método split(String), que é semelhante ao método split() da classe String.
3. O método toString() da classe Pattern retorna a String de expressão regular a partir da qual este padrão foi compilado.
4. As classes Matcher têm os métodos de índice start() e end() que mostram precisamente onde a correspondência foi encontrada na string de entrada.
5. A classe Matcher também fornece métodos de manipulação de String replaceAll(String replacement) e replaceFirst(String replacement).

Vamos analisar esses métodos de regex Java em um exemplo de programa simples.

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// usando padrão com flags
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// usando os métodos find(), group(), start() e end() do Matcher
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// usando o método split() do Pattern
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// usando os métodos replaceFirst() e replaceAll() do Matcher
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

O resultado do exemplo de programa de regex Java acima é.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

Isso é tudo para Expressões Regulares em Java. As Regex em Java podem parecer difíceis no início, mas se você trabalhar com elas por algum tempo, é fácil aprender e usar.

Você pode conferir o código completo e mais exemplos de expressões regulares em nosso Repositório no GitHub.