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

Bem-vindo ao Regular Expression em Java. Também é chamado de Regex em Java. Quando comecei a programar, expressões regulares em Java eram um pesadelo para mim. Este tutorial tem como objetivo ajudá-lo a dominar as Expressões Regulares em Java. Eu também voltarei aqui para revisar meu aprendizado em 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 pesquisar, editar ou manipular texto. Uma expressão regular não é específica de uma linguagem, mas difere ligeiramente para cada linguagem. A 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. Pattern: O objeto Pattern é a versão compilada da expressão regular. A classe Pattern não tem nenhum construtor público, e usamos seu método estático público compile para criar o objeto de padrão passando o argumento da expressão regular.
2. Matcher: Matcher é o objeto do motor de expressão regular Java que corresponde ao padrão de String de entrada com o objeto de padrão criado. A classe Matcher não tem nenhum construtor público e obtemos um objeto Matcher usando o método matcher do objeto padrão que recebe a String de entrada como argumento. Em seguida, usamos o método matches que retorna um resultado booleano com base em se a String de entrada corresponde ao padrão regex ou não.
3. PatternSyntaxException: PatternSyntaxException é lançada se a sintaxe da expressão regular não estiver correta.

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

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 programa de exemplo de regex em Java, obtemos a saída abaixo.

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)

Como a expressão regular em Java gira em torno de String, a classe String foi estendida no Java 1.4 para fornecer um método matches que faz correspondência de padrão regex. Internamente, ele usa as classes java regex Pattern e Matcher para fazer o processamento, mas obviamente reduz as linhas de código. A classe Pattern também contém o método matches 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 String de entrada com 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));

Se o seu requisito é 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 reutilizar o padrão. Note que o padrão definido pela expressão regular é 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 expressão regular “121” corresponderá a “31212142121” apenas duas vezes como “_121____121”.

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

Metacaracteres Regex em Java

Temos alguns metacaracteres em regex Java, é 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

Os Quantificadores em Regex Java especificam o número de ocorrências de um caractere a ser correspondido.

Os 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 agora sobre Grupos de Captura.

Expressão Regular em Java – Grupos de Captura

Grupos de captura em Expressões Regulares Java são usados para tratar vários caracteres como uma única unidade. Você pode criar um grupo usando (). A parte da String de entrada que corresponde ao grupo de captura é salva na memória e pode ser recuperada usando Referência de Retrocesso. 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 Referência de Retrocesso na expressão regular com uma barra invertida (\) e, em seguida, o número do grupo a ser recuperado. Grupos de captura e Referências de Retrocesso 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

Na primeira 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. Portanto, \1 refere-se a “a2” e, portanto, retorna verdadeiro. Por causa da mesma razão, a segunda declaração imprime falso. Tente entender este cenário para as declarações 3 e 4 por si mesmo. 🙂 Agora vamos olhar para 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 insensível a 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 esse 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 dar uma olhada nesses métodos de regex Java em um exemplo simples de programa.

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("_"));
	}

}

A saída 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. Regex em Java parece difícil no início, mas se você trabalhar com elas por algum tempo, é fácil de aprender e usar.

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