O que são expressões regulares em Java?
Em Java , Regex ou Expressão regular é uma interface de programa de aplicativo que ajuda na definição de um padrão para pesquisar, manipular e editar cadeias. As expressões regulares do Java são amplamente usadas na validação de senhas e e-mails. Essas expressões são fornecidas pelo pacote java.util.regex e consistem em 1 interface e 3 classes.
As três classes são:
- Padrão: Ajuda na definição de padrões.
- Correspondente: O uso de padrões ajuda na execução de operações de correspondência.
- PatternSyntaxException: Ajuda na indicação de um erro de sintaxe.
O Java Regex possui uma interface conhecida como MatchResultInterface que ajuda a determinar o resultado da operação de correspondência da expressão regular.
Sintaxe da expressão regular em Java
Agora vamos ver como escrever uma expressão regular em Java com a ajuda de um programa.
Código:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String A = " Happiness is " + " within yourself";
String B = ".*within.*";
// checks whether the string A contains the word 'within' and stores the result in matchcheck
boolean matchcheck = Pattern.matches(B, A);
//prints the result
System.out.println("Is there any string 'within' in the text ? \n " + matchcheck);
) )
Resultado:
Métodos comumente usados em expressões regulares
Existem 3 métodos comumente usados em expressões regulares. Eles são,
1. Métodos de indexação
Os métodos de índice oferecem valores de índice que ajudam a mostrar com precisão onde a correspondência foi encontrada na string fornecida como entrada.
| Método | Descrição |
| começar() | O índice inicial da partida anterior é retornado. |
| start (grupo int) | Dada a operação de correspondência anterior do grupo, a subsequência é capturada e retornada. |
| fim() | O deslocamento após a correspondência do último caractere é retornado. |
| Fim (grupo int) | Dada a operação de correspondência anterior do grupo, a subsequência é capturada e deslocada após a correspondência do último caractere retornado. |
2. Métodos de Estudo
Os métodos de estudo verificam a sequência fornecida como entrada e um valor booleano é retornado, indicando se o padrão foi encontrado ou não.
| Método | Descrição |
| olhando para() | Combine a sequência fornecida como entrada com o padrão desde o início da região. |
| encontrar() | Localiza a próxima subsequência da sequência fornecida como entrada no padrão desde o início da região. |
| find (int start) | Redefine o correspondente e, em seguida, localiza a próxima subsequência da sequência fornecida como entrada no padrão especificado no índice. |
| partidas() | Corresponde o conteúdo ao padrão. |
3. Métodos de substituição
Métodos usados para substituir o texto em uma sequência.
| Método | Descrição |
| appendReplacement (StringBuffer s, substituição de String) | Uma etapa de anexação e substituição não terminal será implementada. |
| appendTail (StringBuffer s) | Uma etapa de anexação e substituição do terminal será implementada. |
| replaceAll (substituição de string) | Substitua toda subsequência da sequência fornecida como entrada que corresponda ao padrão por uma sequência de substituição. |
| quoteReplacement (String s) | Uma string de substituição literal será retornada para a string mencionada. |
| replaceFirst (substituição de string) | Substitua a primeira subsequência da sequência fornecida como entrada que corresponde ao padrão por uma sequência de substituição. |
Como definir expressões regulares em Java?
Existem várias maneiras pelas quais uma expressão regular pode ser definida. Eles são:
1. Literais
Suponha que uma string "hai" precise ser pesquisada em um texto "hai". Isso pode ser feito usando a sintaxe.
Pattern.matches("hai", "hai")
2. Classes de caracteres
Ele corresponde a cada caractere único no texto fornecido como entrada em relação a vários caracteres permitidos na classe de caracteres. A seguir estão as várias construções de classe.
| Classe de Personagem | Explicação |
| (pqr) | Corresponde ao texto se ele contém p, q ou r e deve ser apenas uma vez. |
| (pqr) | denota a negação e, devido a isso, aqui, um caractere único, exceto p, q ou r, é obtido. |
| (a-zA-Z) | a a z e A a Z são considerados. |
| (anúncio (ps)) | a para d ou p para s. |
| (a-dm-p) | União de ambas as faixas. |
| (az && (pqr)) | a a z e (p, q ou r). |
| (az && (pq)) | a a z e também, p, q não são considerados. |
| (ad-z) | Executa a subtração. |
| (az && (mp)) | a a z e não m a p. |
3. Metacaracteres
Os metacaracteres agem como códigos de acesso na expressão regular. A seguir estão alguns dos metacaracteres comumente usados.
| Expressão regular | Explicação |
| \ d | Qualquer dígito de 0 a 9. Também pode ser escrito como (0-9). |
| \ D | Qualquer não dígito de 0 a 9. Também pode ser escrito como (0-9). |
| \ s | Caractere de espaço em branco ou (\ t \ n \ x0B \ f \ r). |
| \ S | Caractere sem espaço em branco ou (\ s). |
| \W | Caractere da palavra ou (a-zA-Z_0-9). |
| \W | Caractere sem palavra ou (\ w). |
| \ b | Limite de palavras. |
| \ B | Limite sem palavras. |
4. Quantificadores
Os quantificadores mencionam a contagem de ocorrência de cada caractere para corresponder à string.
| Expressão regular | Explicação |
| uma? | Ocorre uma vez ou não. |
| UMA* | A ocorre 0 ou mais vezes. |
| A + | A ocorre 1 ou mais vezes. |
| A) | A ocorre exatamente n vezes. |
| A, ) | A ocorre n ou mais que isso. |
| A (n, m) | A ocorre pelo menos n vezes, mas não deve ser superior a m vezes. |
Como criar expressões regulares em Java?
Agora, vamos ver um programa java com as expressões regulares mencionadas acima.
Código:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String str="hai";
// Returns true if string 1 matches string 2
System.out.println("Returns true if 'hai' matches 'Hai' :"+
Pattern.matches(str, "Hai")); //False
//Returns true if Hai or hai matches parameter 2
System.out.println("Returns true if 'Hai' or 'hai' matches 'Hai' : "+
Pattern.matches("(Hh)ai", "Hai")); //True
// Returns true if the string matches exactly "ann" or "Ann" or "jak" or "Jak"
System.out.println("Returns true if the string matches exactly 'ann' or 'Ann' or 'jak' or 'Jak' with 'Ann' : "+
Pattern.matches("(aA)nn|(jJ)ak", "Ann"));//True
//returns true if the string contains "with" at any place in the string
System.out.println("returns true if the string contains 'with' in the string 'within' : " +
Pattern.matches(".*with.*", "within"));//True
// returns true if the '9448anna' does not have number in the beginning
System.out.println( "returns true if the '9448anna' does not have number in the beginning : "+
Pattern.matches("^(^\\d).*", "9448anna")); //False
System.out.println("returns true if the '9448anna' does not have number in the beginning : " +
Pattern.matches("^(^\\d).*", "anna9448")); //True
)
)
Resultado:
Conclusão
As expressões regulares do Java são amplamente usadas para aplicativos em tempo real, como verificação de senha e email. Essas expressões são APIs que definem padrões e oferecem pesquisa, edição e várias outras operações na string.
Artigos recomendados
Este é um guia para expressões regulares em Java. Aqui discutimos como criar, como definir e métodos comumente usados de expressões regulares em java. Você também pode consultar os seguintes artigos para saber mais -
- Os 3 melhores compiladores em Java
- Expressões regulares em JavaScript - propriedades e métodos
- Desenvolvimento de aplicativos Java
- Métodos de matriz em Java com exemplos
- Funções de Regex em Python (Exemplo)