Introdução
Neste laboratório, você aprenderá como verificar se uma string contém caracteres especiais em Java usando expressões regulares (regex). Começaremos definindo caracteres especiais usando padrões regex, compreendendo os caracteres especiais comuns e seu uso.
Após a definição de caracteres especiais, você explorará como usar o método Pattern.matches() para determinar eficientemente se uma string contém algum dos caracteres especiais definidos. Finalmente, você aprenderá como contar as ocorrências de caracteres especiais dentro de uma determinada string, fornecendo uma compreensão abrangente do tratamento de caracteres especiais em Java.
Definir Caracteres Especiais com Regex
Nesta etapa, aprenderemos como definir caracteres especiais usando expressões regulares (regex) em Java. Expressões regulares são ferramentas poderosas para correspondência de padrões em strings. Caracteres especiais em regex têm significados específicos e são usados para definir padrões.
Aqui estão alguns caracteres especiais comuns em regex:
.: Corresponde a qualquer caractere único (exceto nova linha).*: Corresponde ao elemento anterior zero ou mais vezes.+: Corresponde ao elemento anterior uma ou mais vezes.?: Corresponde ao elemento anterior zero ou uma vez.[]: Corresponde a qualquer caractere único dentro dos colchetes.|: Atua como um operador OR.(): Agrupa elementos.\: Escapa um caractere especial, fazendo com que corresponda ao caractere literal.
Por exemplo, se quisermos corresponder a qualquer dígito, podemos usar \d. Se quisermos corresponder a qualquer não-dígito, usamos \D. Da mesma forma, \s corresponde a qualquer caractere de espaço em branco, e \S corresponde a qualquer caractere que não seja espaço em branco.
Vamos criar um programa Java simples para demonstrar como definir um padrão regex para caracteres especiais.
Abra o arquivo
HelloJava.javano editor WebIDE, se ainda não estiver aberto.Substitua todo o conteúdo do arquivo pelo seguinte código:
import java.util.regex.Matcher; import java.util.regex.Pattern; public class HelloJava { public static void main(String[] args) { String text = "Hello! This is a test string with some special characters: @#$%^&*()_+"; // Define a regex pattern to match special characters String regex = "[^a-zA-Z0-9\\s]"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(text); System.out.println("Original String: " + text); System.out.println("Regex Pattern: " + regex); System.out.print("Special characters found: "); while (matcher.find()) { System.out.print(matcher.group() + " "); } System.out.println(); // Print a newline at the end } }Vamos entender as novas partes deste código:
import java.util.regex.Matcher;eimport java.util.regex.Pattern;: Estas linhas importam as classes necessárias para trabalhar com expressões regulares em Java.String regex = "[^a-zA-Z0-9\\s]";: Esta linha define nosso padrão regex.[]: Esta é uma classe de caracteres, o que significa que corresponderá a qualquer caractere único dentro dos colchetes.^: Quando usado no início de uma classe de caracteres ([^...]), ele nega a classe, o que significa que corresponderá a qualquer caractere não na classe.a-zA-Z0-9: Isso corresponde a qualquer letra minúscula (a a z), qualquer letra maiúscula (A a Z) ou qualquer dígito (0 a 9).\\s: Isso corresponde a qualquer caractere de espaço em branco (espaço, tabulação, nova linha, etc.). Usamos\\porque\é um caractere especial em strings Java e precisa ser escapado.- Portanto, o padrão inteiro
[^a-zA-Z0-9\\s]corresponde a qualquer caractere que não seja uma letra, um dígito ou um caractere de espaço em branco. Estes são nossos "caracteres especiais" neste contexto.
Pattern pattern = Pattern.compile(regex);: Esta linha compila o padrão regex em um objetoPattern. Compilar o padrão melhora o desempenho se você estiver usando o mesmo padrão várias vezes.Matcher matcher = pattern.matcher(text);: Esta linha cria um objetoMatcher, que é usado para realizar operações de correspondência na string de entrada (text) usando o padrão compilado.while (matcher.find()): Este loop encontra a próxima subsequência da sequência de entrada que corresponde ao padrão.matcher.group(): Isso retorna a subsequência correspondente.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa usando o comando
javacno Terminal:javac HelloJava.javaExecute o programa compilado usando o comando
java:java HelloJavaVocê deve ver uma saída semelhante a esta:
Original String: Hello! This is a test string with some special characters: @#$%^&*()_+ Regex Pattern: [^a-zA-Z0-9\s] Special characters found: ! : @ ## $ % ^ & * ( ) _ +
Você definiu com sucesso um padrão regex para identificar caracteres especiais e o usou em um programa Java.
Usar Pattern.matches() para Caracteres Especiais
Nesta etapa, exploraremos outra maneira de usar expressões regulares em Java: o método Pattern.matches(). Ao contrário do objeto Matcher que usamos na etapa anterior para encontrar todas as ocorrências de um padrão, Pattern.matches() verifica se a string de entrada inteira corresponde à expressão regular fornecida.
Este método é útil quando você deseja validar se uma string está em conformidade com um formato específico, como verificar se uma senha contém pelo menos um caractere especial, ou se um nome de usuário contém apenas caracteres permitidos.
Vamos modificar nosso programa HelloJava.java para usar Pattern.matches() para verificar se uma string contém quaisquer caracteres especiais com base em nossa regex definida anteriormente.
Abra o arquivo
HelloJava.javano editor WebIDE.Substitua o código existente pelo seguinte:
import java.util.regex.Pattern; public class HelloJava { public static void main(String[] args) { String text1 = "Hello World"; String text2 = "Hello World!"; // Define a regex pattern to check for the presence of special characters // This pattern checks if the string contains at least one character that is NOT a letter, digit, or whitespace String regex = ".*[^a-zA-Z0-9\\s].*"; boolean containsSpecial1 = Pattern.matches(regex, text1); boolean containsSpecial2 = Pattern.matches(regex, text2); System.out.println("String 1: \"" + text1 + "\""); System.out.println("Contains special characters? " + containsSpecial1); System.out.println("String 2: \"" + text2 + "\""); System.out.println("Contains special characters? " + containsSpecial2); } }Vamos analisar as mudanças:
- Precisamos apenas importar
java.util.regex.Pattern;para este método. - O padrão regex agora é
.*[^a-zA-Z0-9\\s].*. Vamos detalhar isso:.*: Isso corresponde a qualquer caractere (.) zero ou mais vezes (*). O primeiro.*corresponde a qualquer coisa antes do caractere especial.[^a-zA-Z0-9\\s]: Esta é a mesma classe de caracteres da etapa anterior, correspondendo a um único caractere especial..*: Isso corresponde a qualquer caractere (.) zero ou mais vezes (*). O segundo.*corresponde a qualquer coisa após o caractere especial.- Combinado,
.*[^a-zA-Z0-9\\s].*significa "corresponder a qualquer string que contenha pelo menos um caractere que não seja uma letra, um dígito ou um espaço em branco".
Pattern.matches(regex, text1): Este método estático da classePatternrecebe o padrão regex e a string de entrada como argumentos e retornatruese a string inteira corresponder ao padrão efalsecaso contrário.
- Precisamos apenas importar
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa:
javac HelloJava.javaExecute o programa:
java HelloJavaVocê deve ver a seguinte saída:
String 1: "Hello World" Contains special characters? false String 2: "Hello World!" Contains special characters? true
Esta saída mostra que Pattern.matches() identificou corretamente que a segunda string contém um caractere especial (!) enquanto a primeira não contém.
Contar Caracteres Especiais em uma String
Nesta etapa final, combinaremos o que aprendemos sobre como definir padrões regex e usar o objeto Matcher para contar o número de caracteres especiais em uma determinada string. Esta é uma aplicação prática de regex para análise ou validação de dados.
Usaremos o mesmo padrão regex da Etapa 1 ([^a-zA-Z0-9\\s]) para identificar caracteres especiais e iterar pela string usando o Matcher para contar quantas vezes o padrão é encontrado.
Abra o arquivo
HelloJava.javano editor WebIDE.Substitua o código existente pelo seguinte:
import java.util.regex.Matcher; import java.util.regex.Pattern; public class HelloJava { public static void main(String[] args) { String text = "This string has 5 special characters: !@#$%"; // Define a regex pattern to match special characters String regex = "[^a-zA-Z0-9\\s]"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(text); int count = 0; while (matcher.find()) { count++; } System.out.println("Original String: \"" + text + "\""); System.out.println("Regex Pattern: " + regex); System.out.println("Number of special characters found: " + count); } }Aqui está o que está acontecendo no novo código:
- Importamos as classes
MatcherePatternnovamente. - Usamos o mesmo padrão regex
[^a-zA-Z0-9\\s]para corresponder a caracteres especiais individuais. - Inicializamos uma variável inteira
countcom 0. - O loop
while (matcher.find())itera pela string, e cada vez que o métodomatcher.find()encontra uma correspondência para o padrão, o código dentro do loop é executado. - Dentro do loop, incrementamos a variável
countem 1 para cada caractere especial encontrado. - Finalmente, imprimimos a contagem total de caracteres especiais.
- Importamos as classes
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa:
javac HelloJava.javaExecute o programa:
java HelloJavaVocê deve ver a seguinte saída:
Original String: "This string has 5 special characters: !@#$%" Regex Pattern: [^a-zA-Z0-9\s] Number of special characters found: 5
A saída mostra corretamente que há 5 caracteres especiais na string fornecida. Você usou com sucesso regex e o objeto Matcher para contar caracteres específicos em uma string.
Resumo
Neste laboratório, aprendemos como definir caracteres especiais usando expressões regulares (regex) em Java. Exploramos caracteres especiais regex comuns e seus significados, como ., *, +, ?, [], |, () e \. Também vimos como usar classes de caracteres predefinidas como \d, \D, \s e \S.
Em seguida, aprendemos como usar o método Pattern.matches() para verificar se uma string contém caracteres especiais com base em um padrão regex definido. Finalmente, exploramos como contar as ocorrências de caracteres especiais dentro de uma string usando o método Matcher.find() e iterando pelas correspondências.
