Regex Java
O Regex Java ou Expressão Regular é uma API para defina um padrão para pesquisar ou manipular strings .
É amplamente utilizado para definir restrições em strings como senha e validação de e-mail. Depois de aprender o tutorial Java regex, você poderá testar suas expressões regulares pela ferramenta Java Regex Tester.
A API Java Regex fornece 1 interface e 3 classes em java.util.regex pacote.
pacote java.util.regex
As classes Matcher e Pattern fornecem a facilidade da expressão regular Java. O pacote java.util.regex fornece as seguintes classes e interfaces para expressões regulares.
- Interface MatchResult
- Classe de correspondência
- Classe padrão
- Classe PatternSyntaxException
Classe de correspondência
Ele implementa o Resultado da partida interface. É um mecanismo regex que é usado para realizar operações de correspondência em uma sequência de caracteres.
| Não. | Método | Descrição |
|---|---|---|
| 1 | correspondências booleanas() | teste se a expressão regular corresponde ao padrão. |
| 2 | busca booleana() | encontra a próxima expressão que corresponde ao padrão. |
| 3 | busca booleana (int início) | encontra a próxima expressão que corresponde ao padrão do número inicial fornecido. |
| 4 | Grupo de strings() | retorna a subsequência correspondente. |
| 5 | int início() | retorna o índice inicial da subsequência correspondente. |
| 6 | pretende() | retorna o índice final da subsequência correspondente. |
| 7 | int grupoContagem() | retorna o número total da subsequência correspondente. |
Classe padrão
É o versão compilada de uma expressão regular . É usado para definir um padrão para o mecanismo regex.
| Não. | Método | Descrição |
|---|---|---|
| 1 | compilação de padrão estático (String regex) | compila o regex fornecido e retorna a instância do Padrão. |
| 2 | Correspondente correspondente (entrada CharSequence) | cria um matcher que combina a entrada fornecida com o padrão. |
| 3 | correspondências booleanas estáticas (String regex, entrada CharSequence) | Funciona como uma combinação de métodos de compilação e matcher. Ele compila a expressão regular e combina a entrada fornecida com o padrão. |
| 4 | String[] divisão (entrada CharSequence) | divide a string de entrada fornecida em torno das correspondências de um determinado padrão. |
| 5 | Padrão de string() | retorna o padrão regex. |
Exemplo de expressões regulares Java
Existem três maneiras de escrever o exemplo regex em Java.
import java.util.regex.*; public class RegexExample1{ public static void main(String args[]){ //1st way Pattern p = Pattern.compile('.s');//. represents single character Matcher m = p.matcher('as'); boolean b = m.matches(); //2nd way boolean b2=Pattern.compile('.s').matcher('as').matches(); //3rd way boolean b3 = Pattern.matches('.s', 'as'); System.out.println(b+' '+b2+' '+b3); }} Teste agora Saída
true true true
Expressão regular . Exemplo
O . (ponto) representa um único caractere.
import java.util.regex.*; class RegexExample2{ public static void main(String args[]){ System.out.println(Pattern.matches('.s', 'as'));//true (2nd char is s) System.out.println(Pattern.matches('.s', 'mk'));//false (2nd char is not s) System.out.println(Pattern.matches('.s', 'mst'));//false (has more than 2 char) System.out.println(Pattern.matches('.s', 'amms'));//false (has more than 2 char) System.out.println(Pattern.matches('..s', 'mas'));//true (3rd char is s) }} Teste agora Classes de caracteres Regex
| Não. | Classe de personagem | Descrição |
|---|---|---|
| 1 | [abc] | a, b ou c (classe simples) |
| 2 | [^abc] | Qualquer caractere exceto a, b ou c (negação) |
| 3 | [a-zA-Z] | de a a z ou de A a Z, inclusive (intervalo) |
| 4 | [a-d[m-p]] | a até d, ou m até p: [a-dm-p] (união) |
| 5 | [a-z&&[def]] | d, e ou f (interseção) |
| 6 | [a-z&&[^bc]] | de a a z, exceto b e c: [ad-z] (subtração) |
| 7 | [a-z&&[^m-p]] | a até z, e não m até p: [a-lq-z](subtração) |
Exemplo de classes de caracteres de expressão regular
import java.util.regex.*; class RegexExample3{ public static void main(String args[]){ System.out.println(Pattern.matches('[amn]', 'abcd'));//false (not a or m or n) System.out.println(Pattern.matches('[amn]', 'a'));//true (among a or m or n) System.out.println(Pattern.matches('[amn]', 'ammmna'));//false (m and a comes more than once) }} Teste agora Quantificadores Regex
Os quantificadores especificam o número de ocorrências de um caractere.
| Regex | Descrição |
|---|---|
| X? | X ocorre uma vez ou nunca |
| 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{y,z} | X ocorre pelo menos y vezes, mas menos que z vezes |
Classes de caracteres de expressão regular e exemplo de quantificadores
import java.util.regex.*; class RegexExample4{ public static void main(String args[]){ System.out.println('? quantifier ....'); System.out.println(Pattern.matches('[amn]?', 'a'));//true (a or m or n comes one time) System.out.println(Pattern.matches('[amn]?', 'aaa'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aammmnn'));//false (a m and n comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aazzta'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'am'));//false (a or m or n must come one time) System.out.println('+ quantifier ....'); System.out.println(Pattern.matches('[amn]+', 'a'));//true (a or m or n once or more times) System.out.println(Pattern.matches('[amn]+', 'aaa'));//true (a comes more than one time) System.out.println(Pattern.matches('[amn]+', 'aammmnn'));//true (a or m or n comes more than once) System.out.println(Pattern.matches('[amn]+', 'aazzta'));//false (z and t are not matching pattern) System.out.println('* quantifier ....'); System.out.println(Pattern.matches('[amn]*', 'ammmna'));//true (a or m or n may come zero or more times) }} Teste agora Metacaracteres Regex
Os metacaracteres de expressões regulares funcionam como códigos de acesso.
| Regex | Descrição |
|---|---|
| . | Qualquer caractere (pode ou não corresponder ao terminador) |
| d | Quaisquer dígitos, exceto [0-9] |
| D | Qualquer não-dígito, abreviação de [^0-9] |
| s | Qualquer caractere de espaço em branco, abreviação de [ x0Bf ] |
| S | Qualquer caractere que não seja espaço em branco, abreviação de [^s] |
| Em | Qualquer caractere de palavra, abreviação de [a-zA-Z_0-9] |
| EM | Qualquer caractere que não seja uma palavra, abreviação de [^w] |
| Um limite de palavra | |
| B | Um limite sem palavras |
Exemplo de metacaracteres de expressão regular
import java.util.regex.*; class RegexExample5{ public static void main(String args[]){ System.out.println('metacharacters d....');\d means digit System.out.println(Pattern.matches('\d', 'abc'));//false (non-digit) System.out.println(Pattern.matches('\d', '1'));//true (digit and comes once) System.out.println(Pattern.matches('\d', '4443'));//false (digit but comes more than once) System.out.println(Pattern.matches('\d', '323abc'));//false (digit and char) System.out.println('metacharacters D....');\D means non-digit System.out.println(Pattern.matches('\D', 'abc'));//false (non-digit but comes more than once) System.out.println(Pattern.matches('\D', '1'));//false (digit) System.out.println(Pattern.matches('\D', '4443'));//false (digit) System.out.println(Pattern.matches('\D', '323abc'));//false (digit and char) System.out.println(Pattern.matches('\D', 'm'));//true (non-digit and comes once) System.out.println('metacharacters D with quantifier....'); System.out.println(Pattern.matches('\D*', 'mak'));//true (non-digit and may come 0 or more times) }} Teste agora Pergunta de expressão regular 1
/*Create a regular expression that accepts alphanumeric characters only. Its length must be six characters long only.*/ import java.util.regex.*; class RegexExample6{ public static void main(String args[]){ System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun32'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'kkvarun32'));//false (more than 6 char) System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'JA2Uk2'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun$2'));//false ($ is not matched) }} Teste agora
Pergunta de expressão regular 2
/*Create a regular expression that accepts 10 digit numeric characters starting with 7, 8 or 9 only.*/ import java.util.regex.*; class RegexExample7{ public static void main(String args[]){ System.out.println('by character classes and quantifiers ...'); System.out.println(Pattern.matches('[789]{1}[0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '99530389490'));//false (11 characters) System.out.println(Pattern.matches('[789][0-9]{9}', '6953038949'));//false (starts from 6) System.out.println(Pattern.matches('[789][0-9]{9}', '8853038949'));//true System.out.println('by metacharacters ...'); System.out.println(Pattern.matches('[789]{1}\d{9}', '8853038949'));//true System.out.println(Pattern.matches('[789]{1}\d{9}', '3853038949'));//false (starts from 3) }} Teste agora Exemplo de localizador Java Regex
import java.util.regex.Pattern; import java.util.Scanner; import java.util.regex.Matcher; public class RegexExample8{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while (true) { System.out.println('Enter regex pattern:'); Pattern pattern = Pattern.compile(sc.nextLine()); System.out.println('Enter text:'); Matcher matcher = pattern.matcher(sc.nextLine()); boolean found = false; while (matcher.find()) { System.out.println('I found the text '+matcher.group()+' starting at index '+ matcher.start()+' and ending at index '+matcher.end()); found = true; } if(!found){ System.out.println('No match found.'); } } } } Saída:
Enter regex pattern: java Enter text: this is java, do you know java I found the text java starting at index 8 and ending at index 12 I found the text java starting at index 26 and ending at index 30
