Validação de Número de Telefone em Java com Regex: Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma string corresponde a um formato de número de telefone em Java usando Expressões Regulares (Regex). Começaremos criando um padrão Regex especificamente projetado para corresponder aos formatos de números de telefone comuns.

Em seguida, você validará uma string de número de telefone fornecida em relação ao padrão Regex criado, usando a classe Matcher do Java. Por fim, você explorará como lidar e corresponder a diferentes variações de formatos de números de telefone, ajustando o padrão Regex.

Criar Regex para Número de Telefone

Nesta etapa, aprenderemos sobre Expressões Regulares (Regex) e como criar uma para corresponder a números de telefone. Regex é uma ferramenta poderosa usada para correspondência de padrões em strings. É como uma linguagem especial para descrever padrões de texto.

Por que precisamos de Regex para números de telefone? Os números de telefone podem vir em muitos formatos (por exemplo, 123-456-7890, (123) 456-7890, 123.456.7890). Regex nos permite definir um padrão que corresponde a todas essas variações.

Vamos criar um programa Java simples que usa Regex para verificar se uma string se parece com um número de telefone.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja 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 phoneNumber = "123-456-7890"; // The string to check
        String regex = "\\d{3}-\\d{3}-\\d{4}"; // The regex pattern

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phoneNumber);

        boolean isMatch = matcher.matches();

        if (isMatch) {
            System.out.println(phoneNumber + " is a valid phone number format.");
        } else {
            System.out.println(phoneNumber + " is not a valid phone number format.");
        }
    }
}
```
Vamos analisar as novas partes deste código:
- import java.util.regex.Matcher; e import java.util.regex.Pattern;: Essas linhas importam as classes necessárias para trabalhar com Regex em Java.
- String phoneNumber = "123-456-7890";: Esta é a string que queremos testar.
- String regex = "\\d{3}-\\d{3}-\\d{4}";: Este é o nosso primeiro padrão Regex. Vamos decompô-lo:
  - \\d: Corresponde a qualquer dígito (0-9). Usamos \\ porque \ é um caractere especial em strings Java, então precisamos escapá-lo.
  - {3}: Corresponde ao elemento anterior exatamente 3 vezes.
  - -: Corresponde ao caractere hífen literalmente.
  - Portanto, \\d{3}-\\d{3}-\\d{4} corresponde a três dígitos, seguidos por um hífen, seguidos por três dígitos, seguidos por um hífen, seguidos por quatro dígitos.
- Pattern pattern = Pattern.compile(regex);: Isso compila a string Regex em um objeto Pattern, que é mais eficiente para correspondência repetida.
- Matcher matcher = pattern.matcher(phoneNumber);: Isso cria um objeto Matcher que executará a operação de correspondência em nossa string phoneNumber usando o pattern compilado.
- boolean isMatch = matcher.matches();: Isso tenta corresponder a toda a string de entrada (phoneNumber) ao padrão. Ele retorna true se toda a string corresponder e false caso contrário.
- O bloco if e else simplesmente imprime uma mensagem com base em se a string correspondeu ao padrão.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Se não houver erros, um arquivo HelloJava.class será criado.
Execute o programa compilado:
```
java HelloJava
```
Você deve ver a saída indicando que "123-456-7890" é um formato de número de telefone válido de acordo com nosso Regex simples.

Nesta etapa, você aprendeu os conceitos básicos de como usar Regex em Java e criou um padrão simples para corresponder a um formato específico de número de telefone. Nas próximas etapas, tornaremos nosso Regex mais flexível para lidar com diferentes formatos.

Validar Número de Telefone com Matcher

Na etapa anterior, criamos um padrão Regex simples e usamos o método matches() da classe Matcher para verificar se uma string inteira correspondia ao padrão. Nesta etapa, exploraremos a classe Matcher mais a fundo e veremos como ela funciona.

A classe Matcher é o mecanismo que executa as operações de correspondência. Ela é criada a partir de um objeto Pattern e é usada para encontrar ocorrências do padrão dentro de uma string de entrada.

Vamos modificar nosso programa para testar uma string diferente e ver como o método matches() se comporta.

Abra o arquivo HelloJava.java no editor WebIDE.
Altere a string phoneNumber para algo que não corresponda exatamente ao nosso padrão atual \\d{3}-\\d{3}-\\d{4}. Por exemplo, altere a linha:
```
String phoneNumber = "123-456-7890"; // The string to check
```
para:
```
String phoneNumber = "My phone number is 123-456-7890."; // The string to check
```
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Desta vez, a saída deve ser:
```
My phone number is 123-456-7890. is not a valid phone number format.
```
Por que isso aconteceu? Porque o método matches() tenta corresponder a toda a string de entrada ao padrão. Como nossa string de entrada contém mais do que apenas o padrão do número de telefone, matches() retorna false.

Se quiséssemos descobrir se o padrão existe em qualquer lugar dentro da string, usaríamos um método diferente, como find(), que exploraremos mais tarde. Por enquanto, estamos focando em validar se a string inteira está em conformidade com um formato específico usando matches().

Compreender a diferença entre matches() e find() é crucial ao trabalhar com Regex em Java. matches() é para validação estrita de toda a string, enquanto find() é para pesquisar o padrão dentro de uma string maior.

Nesta etapa, você viu como o método matches() da classe Matcher funciona e por que é importante entender seu comportamento ao validar formatos de string.

Lidar com Diferentes Formatos de Número de Telefone

No mundo real, os números de telefone nem sempre seguem o formato exato XXX-XXX-XXXX. Eles podem usar pontos (.), espaços (``) ou até mesmo parênteses (()). Nesta etapa, modificaremos nosso padrão Regex para lidar com algumas dessas variações.

Apresentaremos mais alguns conceitos de Regex para tornar nosso padrão mais flexível:

?: Torna o elemento anterior opcional (0 ou 1 vez).
*: Corresponde ao elemento anterior zero ou mais vezes.
+: Corresponde ao elemento anterior uma ou mais vezes.
[]: Define um conjunto de caracteres. Corresponde a qualquer caractere único dentro dos colchetes.
|: Atua como um operador OR. Corresponde ao padrão antes ou depois do |.

Vamos atualizar nosso arquivo HelloJava.java para usar um padrão Regex mais flexível.

Abra o arquivo HelloJava.java no editor WebIDE.
Altere a string regex para o seguinte:
```
String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern
```
Vamos analisar este novo padrão:
- \\(?: Corresponde a um parêntese de abertura opcional (. Precisamos de \\ para escapar do significado especial de ( em Regex, e ? o torna opcional.
- \\d{3}: Corresponde exatamente a três dígitos.
- \\)?: Corresponde a um parêntese de fechamento opcional ).
- [-.\\s]?: Este é um conjunto de caracteres [] que corresponde a um hífen (-), um ponto (.) ou um caractere de espaço em branco (\\s). O ? torna este separador opcional.
- \\d{3}: Corresponde exatamente a três dígitos.
- [-.\\s]?: Corresponde a um hífen, ponto ou separador de espaço em branco opcional novamente.
- \\d{4}: Corresponde exatamente a quatro dígitos.
Este padrão agora pode corresponder a formatos como 123-456-7890, (123) 456-7890, 123.456.7890, 123 456 7890 e até mesmo 1234567890 (sem nenhum separador).

Agora, vamos testar este novo padrão com diferentes formatos de número de telefone. Substitua a string phoneNumber por alguns exemplos diferentes:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        String[] phoneNumbers = {
            "123-456-7890",
            "(123) 456-7890",
            "123.456.7890",
            "123 456 7890",
            "1234567890",
            "invalid-number", // This should not match
            "123-456-789" // This should not match
        };

        String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern

        Pattern pattern = Pattern.compile(regex);

        for (String phoneNumber : phoneNumbers) {
            Matcher matcher = pattern.matcher(phoneNumber);
            boolean isMatch = matcher.matches();

            if (isMatch) {
                System.out.println(phoneNumber + " is a valid phone number format.");
            } else {
                System.out.println(phoneNumber + " is not a valid phone number format.");
            }
        }
    }
}

Introduzimos um array String phoneNumbers para testar facilmente várias entradas e um loop for para iterar sobre elas.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```

Execute o programa compilado:

java HelloJava

Você deve ver uma saída semelhante a esta, mostrando quais strings correspondem ao padrão:

123-456-7890 is a valid phone number format.
(123) 456-7890 is a valid phone number format.
123.456.7890 is a valid phone number format.
123 456 7890 is a valid phone number format.
1234567890 is a valid phone number format.
invalid-number is not a valid phone number format.
123-456-789 is not a valid phone number format.

Você agora criou um padrão Regex mais robusto que pode lidar com vários formatos comuns de números de telefone. Isso demonstra o poder e a flexibilidade do Regex para validar e analisar strings.

Resumo

Neste laboratório, aprendemos como verificar se uma string corresponde a um formato de número de telefone em Java usando Expressões Regulares (Regex). Começamos entendendo o conceito de Regex e sua importância para a correspondência de padrões, especialmente para lidar com vários formatos de números de telefone. Em seguida, criamos um programa Java simples utilizando o pacote java.util.regex.

A primeira etapa envolveu a criação de um padrão Regex básico \\d{3}-\\d{3}-\\d{4} para corresponder ao formato "XXX-XXX-XXXX". Usamos Pattern.compile() para compilar a regex em um objeto Pattern e Pattern.matcher() para criar um objeto Matcher para a string de entrada. Finalmente, usamos matcher.matches() para verificar se toda a string correspondia ao padrão e imprimimos o resultado. Isso estabeleceu a base para validar números de telefone usando Regex em Java.

Como Verificar se uma String Corresponde a um Formato de Número de Telefone em Java

Introdução

Criar Regex para Número de Telefone

Validar Número de Telefone com Matcher

Lidar com Diferentes Formatos de Número de Telefone

Resumo