Validador de IP Address Regex em Java

O que é um Endereço IP?

Um Endereço IP (Internet Protocol) é um identificador único para dispositivos em uma rede. Existe em dois formatos:

• IPv4: 4 octetos decimais (ex.: 192.168.0.1)

• IPv6: 8 blocos hexadecimais (ex.: 2001:0db8:85a3:0000:0000:8a2e:0370:7334)

A validação correta garante que o roteamento de dados e a identificação de dispositivos funcionem sem problemas.

Padrões Regex para IP Address

Padrão Regex para IPv4:

^((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.|$)){4}$

Explicação:

• Garante quatro blocos de números

• Cada bloco varia de 0 a 255

• Pontos separam os blocos
  
  

Veja como isso funciona para endereços IPv4:

• 25[0-5]: Corresponde a números de 250 a 255

• 2[0-4]\d: Corresponde a números de 200 a 249

• 1\d\d: Corresponde a números de 100 a 199

• [1-9]?\d: Corresponde a números de 0 a 99 (lida com dígitos simples ou duplos, garantindo que não haja zeros à esquerda exceto para 0)

Cada um desses padrões garante que cada octeto (o valor entre os pontos) seja um número válido entre 0 e 255. Os grupos são separados por pontos literais, e o padrão como um todo impõe exatamente quatro octetos, conforme exigido pelo padrão IPv4.

Padrão Regex para IPv6:

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Explicação:

• Garante 8 grupos de 1 a 4 dígitos hex

• Grupos separados por dois-pontos

Exemplo JavaScript: Validando Endereços IP

Se você quiser validar endereços IP em JavaScript, as expressões regulares são sua melhor ferramenta. Veja um guia rápido de como verificar endereços IPv4 e IPv6 usando regex.

// Expressões regulares para IPv4 e IPv6
const ipv4Pattern = /^((25[0-5]2[0-4]\d1\d\d[1-9]?\d)(\.$)){4}$/;
const ipv6Pattern = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
/**

Valida se uma string é um endereço IPv4 ou IPv6 válido.
@param {string} ip - Endereço IP a validar.
@returns {string} - O tipo de endereço IP ou 'IP Inválido'.
*/
function validateIPAddress(ip) {
if (ipv4Pattern.test(ip)) {
return "Endereço IPv4 Válido";
}
if (ipv6Pattern.test(ip)) {
return "Endereço IPv6 Válido";
}
return "IP Inválido";
}

// Teste com alguns exemplos:
console.log(validateIPAddress("127.0.0.1"));                       // Endereço IPv4 Válido
console.log(validateIPAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334")); // Endereço IPv6 Válido
console.log(validateIPAddress("300.168.0.1"));                     // IP Inválido

Exemplo de Código Java (IPv4)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class IPv4Validator {
public static void main(String[] args) {
String ip = "192.168.1.1";
String ipv4Regex = "^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.|$)){4}$";
    Pattern pattern = Pattern.compile(ipv4Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Endereço IPv4 Válido");
    } else {
        System.out.println("Endereço IPv4 Inválido");
    }
}

}

Cenários Comuns de Validação

Caso de Teste 1

• Entrada: 000.12.12.034

• Saída: true

Caso de Teste 2

• Entrada: 121.234.12.12

• Saída: true

Caso de Teste 3

• Entrada: 000.12.234.23.23

• Saída: false

Caso de Teste 4

• Entrada: I.Am.not.an.ip

• Saída: false
  
  

Exemplo de Código Java (IPv6)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class IPv6Validator {
public static void main(String[] args) {
String ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
String ipv6Regex = "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$";
    Pattern pattern = Pattern.compile(ipv6Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Endereço IPv6 Válido");
    } else {
        System.out.println("Endereço IPv6 Inválido");
    }
}

}

Entradas de Exemplo

IPv4 Válido:

• 127.0.0.1

• 192.168.100.100

IPv4 Inválido:

• 256.300.888.1

• 192.168.1

IPv6 Válido:

• 2001:0db8:85a3:0000:0000:8a2e:0370:7334

• fe80::1ff:fe23:4567:890a

IPv6 Inválido:

• 2001:db8:85a3::8a2e:370g:7334 (caracteres inválidos)

• 1234:5678:90ab (muito curto)

Exemplos Adicionais:

Considerações de Desempenho

Complexidade de Tempo:
A validação de um endereço IP usando essas expressões regulares opera em tempo linear, ou O(N), onde N é o comprimento da string de entrada.

Complexidade de Espaço:
O uso de espaço permanece constante em O(1), pois o motor de regex não exige memória adicional que escale com o tamanho da entrada.

Casos de Uso

• Rastreamento de Tentativas de Login: Registre IPs de logins bem-sucedidos ou falhos.

• Processamento de Geo IP: Mapeie localizações de usuários com base nos IPs.

• Whitelist de API: Valide IPs recebidos contra listas de permissão.

• Validação de Formulários: Aceite apenas IPs formatados corretamente em painéis admin ou dashboards.

Dicas Pro

• Use regex separado para IPv4 e IPv6 em vez de um padrão unificado para evitar confusões.

• Limpe a entrada antes da validação (ex.: remova espaços em branco).

• Não confie apenas no regex; após validar o formato, use InetAddress.getByName() para confirmar status de roteamento.

• Evite confiar em IPs enviados por usuários para operações sensíveis à segurança.

• Armazene IPs em formato consistente (completo ou abreviado IPv6) nos bancos de dados.

• Use o Testador de Regex Java para testar variações personalizadas (ex.: intervalos CIDR).

Combine com Estas Ferramentas

• Validador de Regex de Endereço MAC em Java - para validar endereços de hardware

• Testador de Regex Java - para testes personalizados de regex

• Validador de Regex de Email em Java - verifique formatos de email de usuários

• Codificador base64 - codifique endereços IP se necessário para headers de API

• Gerador de Token - gere tokens seguros para mapear com IPs