Expressões regulares em Java

Examinaremos o Java regex com exemplos na esperança de que isso nos ajude a alcançar nossos objetivos de aprendizado.

Expressão Regular Java

Ao discutir o Java Regex , as expressões regulares (RE) são sequências de caracteres que compõem um padrão de pesquisa.

É possível usar esse padrão de pesquisa para descrever o que você está procurando ao pesquisar dados no texto.

Em expressões regulares, um único caractere pode ser usado ou um padrão mais complicado pode ser criado.

As operações de pesquisa e substituição de texto podem ser realizadas usando expressões regulares.

Quanto ao Java regex , não há classe integrada para expressões regulares, mas podemos importar o pacote java.util.regex para usar expressões regulares.

Estas aulas estão inclusas no pacote:

  • Classe Padrão – Classifica os padrões (usados ​​na pesquisa).
  • Matcher Class – Usado para encontrar padrões durante a pesquisa
  • Classe PatternSyntaxException – Reporta erros de sintaxe em padrões de expressões regulares

Dê uma olhada em uma frase para instâncias da palavra “mrexamples”:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("mrexamples", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher("Visit mrexamples!");
boolean matchFound = matcher.find();
if(matchFound) {
System.out.println("Match found");
} else {
System.out.println("Match not found");
}
}
}
// We found the output as Match Found
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.regex.Matcher; // Here we import the Matcher class from the java.util package
import java.util.regex.Pattern; // Similarly the regex.Pattern class is called here
public class Main {
public static void main(String[] args) {
Pattern pattern_match = Pattern.compile("Java regex", Pattern.CASE_INSENSITIVE);
Matcher syntax_matcher = pattern_match.matcher("Hello Dear Learner !! We are learning about Java regex in this session");
boolean matchFound = syntax_matcher.find();
if(matchFound) {
System.out.println("The Sentence contains the word Java regex !!");
} else {
System.out.println("Java Regex not found !!");
}
}
}
// Result will be as: The Sentence contains the word Java regex !!
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Índice-

Exemplo de Explicação

Estamos procurando a palavra “Java Regex” em uma frase usando Java regex .

Na primeira etapa, o padrão é compilado usando o método Pattern.compile() . Em pesquisas Java regex , o primeiro parâmetro indica qual padrão está sendo procurado e o segundo parâmetro indica se a insensibilidade a maiúsculas e minúsculas deve ser usada.

Especificar o segundo parâmetro é uma opção.

A busca por um padrão em uma string é feita com o método matcher() . Como resultado, é retornado um objeto Matcher, contendo os detalhes da busca.

Quando o padrão é encontrado na string, o método find() retorna true ; caso contrário, retorna false .

Bandeiras

Compile() usa sinalizadores para alterar como a pesquisa é conduzida. No que diz respeito ao Java regex , aqui estão alguns exemplos:

  1. Pattern.CASE_INSENSITIVE – Ao pesquisar, as maiúsculas e minúsculas não serão consideradas.
  2. Pattern.LITERAL – Ao realizar uma pesquisa, os caracteres especiais não têm nenhum significado ou significado especial. Eles serão tratados como personagens comuns.
  3. Pattern.UNICODE_CASE – Combine-o com o sinalizador CASE_INSENSITIVE, ignora alfabetos não ingleses

Padrões de Expressão Regular

O método Pattern.compile() usa um padrão como seu primeiro parâmetro. Em Java regex , especifica o tipo de pesquisa que será realizada.

Um intervalo de caracteres pode ser encontrado usando colchetes:

Expressões Visão geral
[xyz] Escolha um caractere entre os valores alternativos entre colchetes.
[^xyz] identifica um caractere que não está presente entre os colchetes.
[0-9] Um caractere entre o intervalo de 0 a 9 é escolhido.

Expressão Java [abc]

A expressão [abc] é usada para pesquisar qualquer valor do colchete da expressão após percorrer toda a string:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.regex.Matcher; // Here we import the Matcher class from the java.util package
import java.util.regex.Pattern; // Similarly the regex.Pattern class is called here
public class Main {
public static void main(String[] args) {
Pattern pattern_match = Pattern.compile("[zmq]", Pattern.CASE_INSENSITIVE);
Matcher syntax_matcher = pattern_match.matcher("Hello Dear Learner !! I hope you will be having fun learning java");
boolean matchFound = syntax_matcher.find();
if(matchFound) {
System.out.println("Match Found !! The Sentence contains the characters z,m,q !!");
} else {
System.out.println("Match not found!!");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Expressão Java [^abc]

Este método é usado para mostrar se algum caractere não está presente na frase, mas é dado na expressão:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.regex.Matcher; // Here we import the Matcher class from the java.util package
import java.util.regex.Pattern; // Similarly the regex.Pattern class is called here
public class Main {
public static void main(String[] args) {
Pattern pattern_match = Pattern.compile("[^zmq]", Pattern.CASE_INSENSITIVE);
Matcher syntax_matcher = pattern_match.matcher("Hello Dear Learner !! I hope you will be having fun learning java");
boolean matchFound = syntax_matcher.find();
if(matchFound) {
System.out.println("True !! The Sentence do not contain the characters as z,m,q ");
} else {
System.out.println("False !! z,m,q are a part of the sentence !!");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Expressão Java [0-9]

Se a Frase em busca contiver qualquer número entre 0 a 9 então a seguinte expressão verifica sua existência:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.regex.Matcher; // Here we import the Matcher class from the java.util package
import java.util.regex.Pattern; // Similarly the regex.Pattern class is called here
public class Main {
public static void main(String[] args) {
Pattern pattern_match = Pattern.compile("[0-9]", Pattern.CASE_INSENSITIVE);
Matcher syntax_matcher = pattern_match.matcher("Hello Dear Learner 24 !! I hope you will be having fun learning java");
boolean matchFound = syntax_matcher.find();
if(matchFound) {
System.out.println("True !! The Sentence contains a number between 0 to 9 ");
} else {
System.out.println("False !! Sentence do not contain any number from 0 to 9 !!");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Metacaracteres

Metacaracteres são caracteres que possuem um significado especial associado a eles:

Metacaracteres Visão geral
| Procura uma correspondência para qualquer padrão dividido por |, como carro|bicicleta|ônibus.
. Apenas uma instância de qualquer caractere é encontrada
^ Identifica uma correspondência como o primeiro caractere de uma string, como em: ^mrexamples
$ procura uma correspondência no final da string, como em: mrexamples$
d localiza um dígito
s Um caractere de espaço em branco é pesquisado.
\b localiza uma correspondência no início de uma palavra, como REGEX, ou no final de uma palavra, como REGEX.
uxxxx Identifica o caractere Unicode representado pelo valor hexadecimal xxxx.

Quantificadores

Os quantificadores são usados ​​para definir quantidades das seguintes maneiras:

Quantificadores Visão geral
n+ Identifica qualquer string que tenha pelo menos um n.
n* Verifica qualquer string que tenha n ocorrendo zero ou mais vezes.
n? Qualquer string com zero ou uma ocorrência de n é correspondida.
n{x} Qualquer texto que tenha uma sequência de X n's é correspondido aqui.
n{x,y} Qualquer string contendo uma série de X a Y n's é correspondida.
n{x,} Qualquer string que inclua pelo menos X n's é considerada uma correspondência.

A barra invertida ( ) pode ser usada para escapar de outros caracteres especiais em sua expressão ao procurar por um deles. Como você provavelmente sabe, as próprias barras invertidas precisam ser escapadas em Java , e é por isso que é necessário escapar de caracteres especiais com duas barras invertidas.

Por exemplo, se você deseja encontrar um ou mais pontos de interrogação, pode usar a seguinte expressão: “/? ”

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.