java regex tutorial with regular expression examples
Este tutorial Java Regex explica o que é uma expressão regular em Java, por que precisamos dela e como usá-la com a ajuda de exemplos de expressões regulares:
PARA expressão regular em Java, que é abreviado como “ regex ”É uma expressão usada para definir um padrão de pesquisa para strings.
O padrão de pesquisa pode ser um caractere simples ou uma substring ou pode ser uma string ou expressão complexa que define um padrão específico a ser pesquisado na string.
Além disso, o padrão pode ter que corresponder uma ou mais vezes à string.
=> Visite aqui para ver a série de treinamento Java para todos.
O que você aprenderá:
Expressão regular: por que precisamos dela
Uma expressão regular é usada principalmente para pesquisar um padrão em uma string. Por que procuramos um padrão em uma string? Podemos querer encontrar um determinado padrão em uma string e então manipulá-lo ou editá-lo.
Portanto, em um aplicativo de computador, podemos ter um requisito contínuo de manipulação de vários padrões. Portanto, sempre exigimos regex para facilitar a busca pelo padrão.
Agora, dado um padrão para pesquisar, como exatamente funciona o regex?
Quando analisamos e alteramos o texto usando um regex, dizemos que 'aplicamos o regex à string ou texto'. O que fazemos é aplicar o padrão ao texto em uma direção 'da esquerda para a direita' e a string de origem é combinada com o padrão.
Por exemplo, considere uma string “ ababababab ”. Vamos supor que uma regex ‘aba’ seja definida. Portanto, agora temos que aplicar esta regex à string. Aplicando o regex da esquerda para a direita, o regex corresponderá à string “ aba_aba___ ”, Em dois lugares.
Assim, uma vez que um caractere de origem é usado em uma correspondência, não podemos reutilizá-lo. Assim, depois de encontrar a primeira correspondência aba, o terceiro caractere ‘a’ não foi reutilizado.
o que usar para abrir arquivos jar
java.util.regex
A linguagem Java não fornece nenhuma classe integrada para regex. Mas podemos trabalhar com expressões regulares importando o “ java.util.regex ' pacote.
O pacote java.util.regex fornece uma interface e três classes, conforme mostrado abaixo:
Classe de padrão: Uma classe de padrão representa o regex compilado. A classe Pattern não tem nenhum construtor público, mas fornece métodos compile () estáticos que retornam objetos Pattern e podem ser usados para criar um padrão.
Classe Matcher: O objeto da classe Matcher corresponde ao padrão regex para a string. Como a classe Pattern, essa classe também não fornece nenhum construtor público. Ele fornece o método matcher () que retorna um objeto Matcher.
PatternSyntaxException: Esta classe define uma exceção não verificada. Um objeto do tipo PatternSyntaxException retorna uma exceção não verificada indicando um erro de sintaxe no padrão regex.
Interface MatchResult: A interface MatchResult determina o resultado da correspondência do padrão regex.
Exemplo de Java Regex
Vamos implementar um exemplo simples de regex em Java. No programa a seguir, temos uma string simples como padrão e então combinamos com uma string. A saída imprime a posição inicial e final na string onde o padrão é encontrado.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String args[]) { //define a pattern to be searched Pattern pattern = Pattern.compile('Help.'); // Search above pattern in 'softwareTestingHelp.com' Matcher m = pattern.matcher('softwareTestingHelp.com'); // print the start and end position of the pattern found while (m.find()) System.out.println('Pattern found from position ' + m.start() + ' to ' + (m.end()-1)); } }
Resultado:
Padrão encontrado de 15 a 19
Regex Matcher em Java
A classe matcher implementa a interface MatchResult. Matcher atua como um mecanismo de regex e é usado para realizar a correspondência exata de uma sequência de caracteres.
A seguir estão os métodos comuns da classe Matcher. Possui mais métodos, mas listamos apenas os métodos importantes abaixo.
o que é um bom firewall gratuito para windows 7 de 64 bits?
Não | Método | Descrição |
---|---|---|
7 | int start () | Dá o índice inicial da subsequência combinada e o retorna. |
1 | correspondências booleanas () | Verifica se a regex corresponde ao padrão. |
dois | Padrão padrão () | Retorna o padrão que o matcher interpreta. |
3 | boolean find () | Este método encontra a próxima expressão a ser correspondida ao padrão. |
4 | boolean find (int start) | O mesmo que find (), mas encontra a expressão a ser correspondida a partir da posição inicial fornecida. |
5 | Grupo de strings () | Retorna a subsequência que corresponde ao padrão. |
6 | Grupo de strings (nome da string) | Retorna a subsequência de entrada. Isso é capturado na operação de correspondência anterior, capturando o grupo com o nome especificado. |
8 | pretender() | Retorna a posição final / índice da subsequência combinada. |
9 | int groupCount () | Retorne o número total de subsequências correspondentes. |
10 | String replaceAll (substituição de string) | Substitua todas as subsequências da sequência de entrada que correspondem ao padrão por uma determinada string de substituição. |
onze | String replaceFirst (substituição de string) | Substitua a primeira subsequência correspondente da sequência de entrada pela string de substituição especificada. |
12 | String toString () | Retorna a representação de string do matcher atual. |
Exemplo de implementação de expressão regular
Vejamos um exemplo do uso de alguns desses métodos.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String[] args) { String inputString = 'She sells sea shells on the sea shore with shells'; //obtain a Pattern object Pattern pattern = Pattern.compile('shells'); // obtain a matcher object System.out.println('input string: ' + inputString); Matcher matcher = pattern.matcher(inputString); inputString = matcher.replaceFirst('pearls'); System.out.println('
replaceFirst method:' + inputString); //use replaceAll method to replace all occurrences of pattern inputString = matcher.replaceAll('pearls'); System.out.println('
replaceAll method:' + inputString); } }
Resultado:
string de entrada: ela vende conchas do mar na costa do mar com conchas
Método replaceFirst: ela vende pérolas do mar na costa do mar com conchas
Método replaceAll: ela vende pérolas do mar na costa do mar com pérolas
Classe de padrão Regex em Java
A classe de padrão define o padrão para o mecanismo regex que pode ser usado para corresponder à string de entrada.
A tabela a seguir mostra os métodos fornecidos pela classe Pattern que é comumente usada.
Não | Método | Descrição |
---|---|---|
7 | String [] split (entrada CharSequence, limite interno) | A string de entrada é dividida em correspondências encontradas por um determinado padrão. |
1 | compilação de padrão estático (String regex) | Retorna a representação compilada da regex. |
dois | compilação de padrão estático (String regex, sinalizadores int) | Compila a regex fornecida usando sinalizadores especificados e padrão de retorno. |
3 | Corresponde às correspondências (entrada CharSequence) | Retorna um matcher combinando a sequência de entrada com o padrão. |
4 | correspondências booleanas estáticas (String regex, entrada CharSequence) | Compila a regex fornecida e combina o padrão com uma determinada entrada. |
5 | sinalizadores int () | Retorna sinalizadores do padrão com o qual a correspondência é feita. |
6 | String [] split (entrada CharSequence) | A string de entrada é dividida em correspondências encontradas por um determinado padrão. |
8 | Padrão de string () | Retorna o padrão de expressão regular. |
9 | Citação de String estática (String s) | Retorna uma String literal (padrão) para a String fornecida. |
10 | String toString () | Obtenha a representação de string do padrão. |
O exemplo a seguir usa alguns dos métodos acima da classe Pattern.
import java.util.regex.*; public class Main { public static void main(String[] args) { // define a REGEX String String REGEX = 'Test'; // string to be searched for given pattern String actualString = 'Welcome to SoftwareTestingHelp portal'; // generate a pattern for given regex using compile method Pattern pattern = Pattern.compile(REGEX); // set limit to 2 int limit = 2; // use split method to split the string String[] array = pattern.split(actualString, limit); // print the generated array for (int i = 0; i Resultado:
array [0] = Bem-vindo ao software
array [1] = portal ingHelp
No programa acima, usamos o método de compilação para gerar um padrão. Em seguida, dividimos a string de entrada sobre esse padrão e a lemos em um array. Finalmente, exibimos o array que foi gerado como resultado da divisão da string de entrada.
Método de correspondências de string Regex
Vimos o método String.Contains () em nossos tutoriais de string. Este método retorna um valor booleano true ou false dependendo se a string contém um caractere especificado nela ou não.
Da mesma forma, temos um método “match ()” para verificar se a string corresponde a uma expressão regular ou regex. Se a string corresponder ao regex especificado, um valor verdadeiro será retornado ou falso será retornado.
A sintaxe geral do método Match ():
public boolean matches (String regex)
Se a regex especificada não for válida, a “PatternSyntaxException” será lançada.
Vamos implementar um programa para demonstrar o uso do método match ().
public class MatchesExample{ public static void main(String args[]){ String str = new String('Java Series Tutorials'); System.out.println('Input String: ' + str); //use matches () method to check if particular regex matches to the given input System.out.print('Regex: (.*)Java(.*) matches string? ' ); System.out.println(str.matches('(.*)Java(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)Series(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)String(.*)')); System.out.print('Regex: (.*)Tutorials matches string? ' ); System.out.println(str.matches('(.*)Tutorials')); } }
Resultado:
String de entrada: Tutoriais da série Java
Regex: (. *) Java (. *) Corresponde à string? verdade
Regex: (. *) Série (. *) Corresponde a string? verdade
Regex: (. *) Série (. *) Corresponde a string? falso
Regex: (. *) Tutoriais corresponde a string? verdade
Usamos muitos caracteres especiais e metacaracteres com expressões regulares em Java. Também usamos muitas classes de caracteres para correspondência de padrões. Nesta seção, forneceremos as tabelas contendo classes de caracteres, caracteres Meta e quantificadores que podem ser usados com regex.
Classes de caracteres Regex
Não Classe de personagem Descrição 7 [a-z && [^ m-p]] Subtração: a a z, e não m a p: [a-lq-z] 1 [pqr] p, q ou r dois [^ pqr] Negação: qualquer caractere diferente de p, q ou r 3 [a-zA-Z] Intervalo: a a z ou A a Z, inclusive 4 [a-d [m-p]] União: a a d, ou m a p: [a-dm-p] 5 [a-z && [def]] Interseção: d, e ou f 6 [a-z && [^ bc]] Subtração: a até z, exceto para b e c: [ad-z]
Quantificadores Regex
Quantificadores são usados para especificar o número de vezes que o caractere ocorrerá na regex.
A tabela a seguir mostra os quantificadores regex comuns usados em Java.
Não Quantificador Regex Descrição 7 NO Qualquer caractere diferente de palavra, [^ w] 1 x? x aparece uma vez ou não aparece dois x + x aparece uma ou mais vezes 3 x * x ocorre zero ou mais vezes 4 x {n} x ocorre n vezes 5 x {n,} x ocorre n ou mais vezes 6 X e Z} x ocorre pelo menos y vezes, mas menos que z vezes
Metacaracteres Regex
Os metacaracteres em regex funcionam como códigos abreviados. Esses códigos incluem espaços em branco e caracteres que não são espaços em branco, juntamente com outros códigos de acesso.
A tabela a seguir lista os metacaracteres regex.
Não Metacaracteres Descrição 1 . Qualquer caractere (pode ou não corresponder ao terminador) dois d Quaisquer dígitos, [0-9] 3 D Qualquer não dígito, [^ 0-9] 4 s Qualquer caractere de espaço em branco, [ t n x0B f r] 5 S Qualquer caractere diferente de espaço em branco, [^ s] 6
o Qualquer caractere de palavra, [a-zA-Z_0-9] 8 b Um limite de palavra 9 B Um limite sem palavras
A seguir, é fornecido um programa Java que usa os caracteres especiais acima no Regex.
import java.util.regex.*; public class RegexExample{ public static void main(String args[]){ // returns true if string exactly matches 'Jim' System.out.print('Jim (jim):' + Pattern.matches('Jim', 'jim')); // Returns true if the input string is Peter or peter System.out.println('
[Pp]eter(Peter) :' + Pattern.matches('[Pp]eter', 'Peter')); //true if string = abc System.out.println('
.*abc.*(pqabcqp) :' + Pattern.matches('.*abc.*', 'pqabcqp')); // true if string doesn't start with a digit System.out.println('
^[^\d].*(abc123):' + Pattern.matches('^[^\d].*', 'abc123')); // returns true if the string contains exact three letters System.out.println('
[a-zA-Z][a-zA-Z][a-zA-Z] (aQz):' + Pattern.matches('[a-zA-Z][a-zA-Z][a-zA-Z]', 'aQz')); System.out.println('
[a-zA-Z][a-zA-Z][a-zA-Z], a10z' + Pattern.matches('[a-zA-Z][a-zA-Z][a-zA-Z], a10z', 'a10z')); //input string length = 4 // true if the string contains 0 or more non-digits System.out.println('
\D*, abcde:' + Pattern.matches('\D*', 'abcde')); //True // true of line contains only word this ^-start of the line, $ - end of the line System.out.println('
^This$, This is Java:' + Pattern.matches('^This$', 'This is Java')); System.out.println('
^This$, This:' + Pattern.matches('^This$, This', 'This')); System.out.println('
^This$, Is This Java?:' + Pattern.matches('^This$, Is This Java?', 'Is This Java?')); } }
Resultado:
Jim (Jim): falso
[Pp] eter (Peter): verdadeiro
. * abc. * (pqabcqp): verdadeiro
^ [^ d]. * (abc123): verdadeiro
[a-zA-Z] [a-zA-Z] [a-zA-Z] (aQz): verdadeiro
[a-zA-Z] [a-zA-Z] [a-zA-Z], a10zfalse
D *, abcde: true
^ This $, This is Java: false
^ Este $, Este: falso
^ This $, Is This Java?: False
No programa acima, fornecemos várias expressões regulares que correspondem à string de entrada. Os leitores são aconselhados a ler os comentários no programa para cada regex para entender melhor o conceito.
Operador lógico ou (|) Regex
Podemos usar o lógico or (| operador) na regex que nos dá a opção de selecionar qualquer operando de | operador. Podemos usar esse operador em uma regex para dar uma escolha de caractere ou string. Por exemplo, se quisermos combinar ambas as palavras, 'teste' e 'Teste', então incluiremos essas palavras em lógico ou operador como Teste | teste.
Vamos ver o seguinte exemplo para entender esse operador.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexOR { public static void main(String[] args) { // Regex string to search for patterns Test or test String regex = '(Test|test)'; // Compiles the pattern and obtains the matcher object from input string. Pattern pattern = Pattern.compile(regex); String input = 'Software Testing Help'; Matcher matcher = pattern.matcher(input); // print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } //define another input string and obtain the matcher object input = 'SoftwaretestingHelp'; matcher = pattern.matcher(input); // Print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } } }
Resultado:
Texto “Teste” encontrado em 9 a 13.
Texto “teste” encontrado em 8 a 12.
Neste programa, fornecemos a regex “(Teste | teste)”. Em seguida, primeiro fornecemos a string de entrada como “Ajuda para teste de software” e correspondemos ao padrão. Vemos que a correspondência é encontrada e a posição é impressa.
A seguir, fornecemos a string de entrada como “SoftwaretestingHelp”. Desta vez também a correspondência é encontrada. Isso ocorre porque a regex usou o operador ou e, portanto, o padrão em ambos os lados de | operador é combinado com a string.
Validação de e-mail usando Regex
Também podemos validar o id (endereço) do e-mail com regex usando o método java.util.regex.Pattern.matches (). Corresponde ao id de email fornecido com a regex e retorna true se o email for válido.
O programa a seguir demonstra a validação de e-mail usando regex.
public class EmailDemo { static boolean isValidemail(String email) { String regex = '^[\w-_\.+]*[\w-_\.]\@([\w]+\.)+[\w]+[\w]$'; //regex to validate email. return email.matches(regex); //match email id with regex and return the value } public static void main(String[] args) { String email = 'ssthva@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); email = '@sth@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); } }
Resultado:
O ID do email é: ssthva@gmail.com
ID de email válido? verdade
O ID do email é: @ sth @ gmail.com
ID de email válido? falso
Como podemos ver na saída acima, o primeiro id de e-mail é válido. O segundo id começa diretamente com @ e, portanto, regex não o valida. Portanto, é um id inválido.
melhor aplicativo de download de música mp3 grátis para Android
perguntas frequentes
P # 1) O que é uma expressão regular?
Responda: PARA Expressão regular comumente chamado de regex é um padrão ou uma sequência de caracteres (normal ou especial ou caracteres Meta) que é usado para validar uma string de entrada.
P # 2) Qual é o significado da classe Matcher para uma expressão regular em Java?
Responda: A classe matcher (java.util.regex.Matcher) atua como um mecanismo regex. Ele executa as operações de correspondência interpretando o padrão.
P # 3) Qual é o padrão em Java?
Responda: O pacote java.util.regex fornece uma classe Pattern que é usada para compilar um regex em um padrão que é a representação padrão para regex. Esse padrão é então usado para validar strings combinando-o com o padrão.
Q # 4) O que é B em uma expressão regular?
Responda: O B na regex é denotado como b e é um caractere âncora usado para corresponder a uma posição chamada limite de palavra. O início da linha é denotado por um acento circunflexo (^) e o final da linha é denotado por um cifrão ($).
P # 5) O padrão é Java thread-safe?
Responda: sim. As instâncias da classe Pattern são imutáveis e seguras para uso por vários threads simultâneos. Mas as instâncias da classe matcher não são thread-safe.
Conclusão
Neste tutorial, discutimos Expressões regulares em Java. A expressão regular, também conhecida como ‘regex’, é usada para validar a string de entrada em Java. Java fornece o ‘ java.util.regex ' pacote que fornece classes como Pattern, Matcher, etc. que ajudam a definir e combinar o padrão com a string de entrada.
Também vimos várias classes de caracteres especiais e metacaracteres que podemos usar na regex que fornecem códigos abreviados para correspondência de padrões. Também exploramos a validação de e-mail usando regex.
=> Explore a série de treinamento simples em Java aqui.
Leitura recomendada