A extração ou validação de dados é um aspecto importante de toda linguagem de programação. Uma das formas mais populares de validação de dados é usando expressões regulares. usa estesexpressões regulares para descrever um padrão de caracteres. Este artigo sobre Java Regex irá listar os vários métodos de uso de expressões na seguinte sequência:
- O que são expressões regulares?
- O que é Java Regex?
- Classe Matcher
- Classe de Padrão
- Classe de personagem Regex
- Quantificadores Regex
- Metacaracteres Regex
Vamos começar!
O que são expressões regulares?
PARA Expressão regular é uma sequência de caracteres que constrói um padrão de pesquisa. Ao pesquisar dados em um texto, você pode usar esse padrão de pesquisa para descrever o que está procurando.
Uma expressão regular pode ser um caractere único ou um padrão mais complicado. Ele pode ser usado para qualquer tipo de pesquisa de texto e operações de substituição de texto. Um padrão Regex consiste em caracteres simples, como / abc / ou uma combinação de caracteres simples e especiais, como /abc/ ou /example(d+).d*/ .
O que é Java Regex?
o Java Regex é uma API usada para definir um padrão para pesquisar ou manipular . É amplamente usado para definir a restrição em Strings, como senha e validação de e-mail.
Existem diferentes métodos de uso do Java Regex. Então, vamos seguir em frente e dar uma olhada nas diferentes expressões.
Classe Matcher
Esta classe é usada para executar operações de correspondência em uma sequência de caracteres. A tabela abaixo representa vários métodos da classe Matcher.
| Método | Descrição |
|---|---|
| correspondências booleanas () | Testa se a expressão regular fornecida corresponde ao padrão |
| boolean find () | Usado para encontrar a próxima expressão que corresponde ao padrão |
| boolean find (int start) | Procura a próxima expressão que corresponda ao padrão do número inicial fornecido |
| Grupo de strings () | Usado para retornar a subsequência combinada |
| int start () | Retorna o índice inicial da subsequência combinada |
| pretender() | Retorna o índice final da subsequência combinada |
| int groupCount () | Retorna o número total da subsequência combinada |
Classe de Padrão
Classe de padrão é uma versão compilada de expressão regular que é usada para definir o padrão para o motor regex.
| Método | Descrição |
|---|---|
| compilação de padrão estático (String regex) | Ele compila o regex fornecido e retorna a instância do padrão |
| Corresponde às correspondências (entrada CharSequence) | É usado para criar um matcher que combina a entrada dada com o padrão |
| correspondências booleanas estáticas (String regex, entrada CharSequence) | Ele funciona como uma combinação de métodos de compilação e combinação. Ele compila a expressão regular e combina a entrada fornecida com o padrão |
| String [] split (entrada CharSequence) | Usado para dividir a string de entrada fornecida em torno de correspondências de um determinado padrão |
| Padrão de string () | Ajuda a retornar o padrão regex |
Agora vamos dar um pequeno exemplo para entender como escrever uma expressão regular.
import java.util.regex. * public class RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('String corresponde ao Regex - + matcher.matches ())}}Neste caso, ele usa internamente Pattern and Matcher classes regex para fazer o processamento, mas obviamente,ele reduz as linhas de código. A classe de padrão também contém o método de correspondências que recebe regex e string de entrada como argumento e retorna um resultado booleano após combiná-los. Portanto, o código funciona bem para correspondência de entrada com uma expressão regular em Java. Portanto, a saída será verdadeira, conforme mostrado abaixo.
Resultado:
verdade
ansible vs fantoche vs chef
Agora vamos ver mais algumas categorias de expressões regulares Java.
Classe de personagem Regex
A tabela abaixo representa as diferentes combinações de classes de caracteres.
| Classe de Personagem | Descrição |
|---|---|
| [abc] | a, b ou c (classe simples) |
| [^ abc] | Qualquer caractere, exceto a, b ou c (negação) |
| [a-zA-Z] | a a z ou A a Z, inclusive (intervalo) |
| [a-d [m-p]] | a a d, ou m a p: [a-dm-p] (união) |
| [a-z && [def]] | d, e ou f (interseção) |
| [a-z && [^ bc]] | a a z, exceto para b e c: [ad-z] (subtração) |
| [a-z && [^ m-p]] | a a z, e não m a p: [a-lq-z] (subtração) |
Exemplo:
import java.util.regex. * public class CharacterExample {public static void main (String args []) {// false (não x ou y ou z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // verdadeiro (entre x ou y ou z) System.out.println (Pattern.matches ('[xyz]', 'x')) // falso (x e y vêm mais de uma vez) Sistema .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Quantificadores Regex
Os quantificadores especificam o número de ocorrências de um caractere. A tabela abaixo representa vários quantificadores.
| Regex | Descrição |
|---|---|
| X? | X ocorre uma vez ou não ocorre |
| X + | X ocorre uma ou mais vezes |
| X * | X ocorre zero ou mais vezes |
| X {n} | X ocorre n vezes apenas |
| X {n,} | X ocorre n ou mais vezes |
| X e Z} | X ocorre pelo menos y vezes, mas menos que z vezes |
Exemplo:
import java.util.regex. * public class Exemplo {public static void main (String args []) {System.out.println ('? quantifier ....') // (a ou y ou z vem uma vez) System.out.println (Pattern.matches ('[ayz]?', 'A')) // output: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay ez vem mais de uma vez) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a vem mais de uma vez) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // output: false // (a ou y ou z deve vir uma vez) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // output: false System.out.println (' + quantifier .... ') // (a ou y ou z uma ou mais vezes) System.out.println (Pattern .matches ('[ayz] +', 'a')) // output: true // (a vem mais de uma vez) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a ou y ou z vem mais de uma vez) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z e t não correspondem ao padrão) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // output: false System.out.println ('* quantifier ....') // (a ou y ou z pode vir zero ou mais vezes ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // output: true}}Basicamente, ele pesquisará o quantificador correspondente e corresponderá ao resultado da pesquisa.
Metacaracteres Regex
Os metacaracteres da expressão regular funcionam como códigos de acesso. Vamos dar uma olhada na tabela abaixo para entender os vários tipos de metacaracteres.
| Regex | Descrição |
|---|---|
| . | Pode ser qualquer caractere (pode ou não corresponder ao terminador) |
| d | Representa qualquer dígito, menor que [0-9] |
| D | Representa qualquer não dígito, abreviação de [^ 0-9] |
| s | Representa qualquer caractere de espaço em branco, abreviação de [tnx0Bfr] |
| S | Pode ser um caractere sem espaço em branco, abreviação de [^ s] |
| dentro | Pode ser um caractere de palavra, abreviação de [a-zA-Z_0-9] |
| DENTRO | Representa qualquer caractere não verbal, abreviação de [^ w] |
| b | Representa um limite de palavra |
| B | É um limite sem palavras |
Exemplo:
import java.util.regex. * public class MetacharExample {public static void main (String args []) {// d significa dígito System.out.println ('metacaracteres d ....') // (não dígitos) System.out.println (Pattern.matches ('d', 'abc')) // Saída: falso // (dígito e vem uma vez) System.out.println (Pattern.matches ('d', '1') ) // Saída: verdadeiro // (dígito, mas vem mais de uma vez) System.out.println (Pattern.matches ('d', '4443')) // Saída: falso // (dígito e caractere) System.out .println (Pattern.matches ('d', '323abc')) // Saída: falso // D significa System.out.println sem dígitos ('metacaracteres D ....') // (sem dígitos, mas vem mais de uma vez) System.out.println (Pattern.matches ('D', 'abc')) // Saída: falso // É um dígito System.out.println (Pattern.matches ('D', '1 ')) // Saída: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Saída: false // (dígito e caractere) System.out.println (Pattern.matches (' D ',' 323abc ')) // Saída: falso // (sem dígito e vem uma vez) System.out.println (Pattern.matches (' D ',' m ')) // Saída: true System.out .pr intln ('metacaracteres D com quantificador ....') // (não dígitos e pode vir 0 ou mais vezes) System.out.println (Pattern.matches ('D *', 'abc')) // Saída : verdade } }Com base nas condições mencionadas acima, ele exibirá a saída. É assim que funciona. Então, isso foi tudo sobre vários tipos de Regex. Com isso, chegamos ao final deste artigo. Euespero que você tenha achado informativo. Se você deseja saber mais, pode verificar nosso também.
Confira o pela Edureka, uma empresa de aprendizagem online confiável com uma rede de mais de 250.000 alunos satisfeitos espalhados por todo o mundo. Estamos aqui para ajudá-lo em todas as etapas de sua jornada, para nos tornarmos uma pergunta além dessa entrevista java, nós criamos um currículo que é projetado para estudantes e profissionais que desejam ser um desenvolvedor Java.
Tem alguma questão para nós? Mencione isso na seção de comentários deste artigo “Java Regex” e entraremos em contato com você o mais breve possível.