Regex e JSON

Regex e JSON são ferramentas comuns de processamento de dados. Esta lição aborda seu uso em Java.

Expressões Regulares

Regex é usada para correspondência, busca e substituição de strings.

Sintaxe Básica

Sintaxe	Descrição	Exemplo
`.`	Qualquer caractere	`a.c` corresponde a "abc"
`\d`	Dígito	`\d+` corresponde a "123"
`\w`	Caractere de palavra	`\w+` corresponde a "hello_123"
`\s`	Espaço em branco	`\s+` corresponde a espaços/tabs
`^`	Início	`^Hello` corresponde ao início
`$`	Fim	`World$` corresponde ao fim
`*`	0 ou mais	`ab*c` corresponde a "ac", "abc"
`+`	1 ou mais	`ab+c` corresponde a "abc", "abbc"
`?`	0 ou 1	`ab?c` corresponde a "ac", "abc"
`{n}`	n vezes	`a{3}` corresponde a "aaa"
`{n,m}`	de n a m vezes	`a{2,4}` corresponde a "aa", "aaa"
`[]`	Conjunto de caracteres	`[abc]` corresponde a "a", "b", "c"
`\|`	Ou	`cat\|dog` corresponde a "cat" ou "dog"
`()`	Grupo	`(ab)+` corresponde a "ab", "abab"

Pattern e Matcher

JAVA

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

public class RegexDemo {
    public static void main(String[] args) {
        String text = "Meu email é test@example.com, telefone é 13812345678";
        
        // Correspondência de email
        Pattern emailPattern = Pattern.compile("\\w+@\\w+\\.\\w+");
        Matcher emailMatcher = emailPattern.matcher(text);
        if (emailMatcher.find()) {
            System.out.println("Email: " + emailMatcher.group());
        }
        
        // Correspondência de telefone
        Pattern phonePattern = Pattern.compile("1[3-9]\\d{9}");
        Matcher phoneMatcher = phonePattern.matcher(text);
        if (phoneMatcher.find()) {
            System.out.println("Telefone: " + phoneMatcher.group());
        }
    }
}

Métodos Comuns

JAVA

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

public class RegexMethods {
    public static void main(String[] args) {
        String text = "Olá 123 Mundo 456 Java 789";
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(text);
        
        // find(): Encontrar próxima correspondência
        while (matcher.find()) {
            System.out.println("Encontrado: " + matcher.group());
            System.out.println("Posição: " + matcher.start() + "-" + matcher.end());
        }
        
        // matches(): Correspondência completa
        System.out.println(Pattern.matches("\\d+", "123"));   // true
        System.out.println(Pattern.matches("\\d+", "123a"));  // false
        
        // split(): Dividir
        String[] parts = "a,b,c".split(",");
        for (String part : parts) {
            System.out.println(part);
        }
        
        // replaceAll(): Substituir todas
        String result = "Olá 123 Mundo".replaceAll("\\d+", "***");
        System.out.println(result);  // Olá *** Mundo
    }
}

Exemplo: Padrões Regex Comuns

JAVA

public class CommonRegex {
    public static void main(String[] args) {
        // Validação de email
        String emailRegex = "^[\\w.-]+@[\\w.-]+\\.\\w+$";
        System.out.println(Pattern.matches(emailRegex, "test@example.com"));  // true
        
        // Validação de telefone
        String phoneRegex = "^1[3-9]\\d{9}$";
        System.out.println(Pattern.matches(phoneRegex, "13812345678"));  // true
        
        // Validação de CPF (formato brasileiro)
        String cpfRegex = "^\\d{3}\\.\\d{3}\\.\\d{3}-\\d{2}$";
        System.out.println(Pattern.matches(cpfRegex, "123.456.789-00"));  // true
        
        // Validação de endereço IP
        String ipRegex = "^((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$";
        System.out.println(Pattern.matches(ipRegex, "192.168.1.1"));  // true
    }
}

▶ Experimente

Captura de Grupos

JAVA

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

public class GroupDemo {
    public static void main(String[] args) {
        String text = "2026-06-24";
        Pattern pattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
        Matcher matcher = pattern.matcher(text);
        
        if (matcher.matches()) {
            System.out.println("Data completa: " + matcher.group(0));  // 2026-06-24
            System.out.println("Ano: " + matcher.group(1));       // 2026
            System.out.println("Mês: " + matcher.group(2));       // 06
            System.out.println("Dia: " + matcher.group(3));       // 24
        }
    }
}

Processamento JSON

JSON é um formato leve de troca de dados.

Análise JSON Manual

JAVA

public class JsonParseDemo {
    public static void main(String[] args) {
        String json = "{\"nome\":\"Alice\",\"idade\":25,\"cidade\":\"São Paulo\"}";
        
        // Análise simples (não recomendada, use biblioteca em projetos reais)
        json = json.replace("{", "").replace("}", "").replace("\"", "");
        String[] pairs = json.split(",");
        
        for (String pair : pairs) {
            String[] kv = pair.split(":");
            System.out.println(kv[0].trim() + " = " + kv[1].trim());
        }
    }
}

Usando Biblioteca JSON (Jackson)

JAVA

// Após adicionar a dependência do Jackson
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        
        // Objeto para JSON
        User user = new User("Alice", 25, "São Paulo");
        String json = mapper.writeValueAsString(user);
        System.out.println("JSON: " + json);
        // {"nome":"Alice","idade":25,"cidade":"São Paulo"}
        
        // JSON para objeto
        User parsed = mapper.readValue(json, User.class);
        System.out.println("Objeto: " + parsed);
    }
}

class User {
    private String nome;
    private int idade;
    private String cidade;
    
    public User() {}  // Jackson requer construtor sem argumentos
    
    public User(String nome, int idade, String cidade) {
        this.nome = nome;
        this.idade = idade;
        this.cidade = cidade;
    }
    
    // Getters/Setters
    public String getNome() { return nome; }
    public void setNome(String nome) { this.nome = nome; }
    public int getIdade() { return idade; }
    public void setIdade(int idade) { this.idade = idade; }
    public String getCidade() { return cidade; }
    public void setCidade(String cidade) { this.cidade = cidade; }
    
    @Override
    public String toString() {
        return "User{nome='" + nome + "', idade=" + idade + ", cidade='" + cidade + "'}";
    }
}

Arrays JSON

JAVA

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class JsonArrayDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        
        // Array JSON
        String json = "[{\"nome\":\"Alice\",\"idade\":25},{\"nome\":\"Bob\",\"idade\":30}]";
        
        // Analisar para List
        List<User> users = mapper.readValue(json, new TypeReference<List<User>>() {});
        users.forEach(System.out::println);
        
        // List para JSON
        String result = mapper.writeValueAsString(users);
        System.out.println(result);
    }
}

Operações JSON Comuns

JAVA

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonNodeDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        String json = "{\"nome\":\"Alice\",\"idade\":25,\"endereco\":{\"cidade\":\"São Paulo\",\"cep\":\"01000-000\"}}";
        
        // Analisar para JsonNode
        JsonNode node = mapper.readTree(json);
        
        // Obter valores
        System.out.println("nome: " + node.get("nome").asText());
        System.out.println("idade: " + node.get("idade").asInt());
        System.out.println("cidade: " + node.get("endereco").get("cidade").asText());
        
        // Verificar existência
        System.out.println("tem email: " + node.has("email"));
    }
}

Métodos Regex de String

JAVA

public class StringRegex {
    public static void main(String[] args) {
        String text = "Olá 123 Mundo 456";
        
        // matches(): Correspondência completa
        System.out.println("123".matches("\\d+"));  // true
        
        // replaceAll(): Substituir todas as correspondências
        String result = text.replaceAll("\\d+", "***");
        System.out.println(result);  // Olá * Mundo *
        
        // replaceFirst(): Substituir primeira correspondência
        String result2 = text.replaceFirst("\\d+", "***");
        System.out.println(result2);  // Olá *** Mundo 456
        
        // split(): Dividir
        String[] parts = "a,b,,c".split(",");  // Manter strings vazias
        System.out.println(parts.length);  // 4
        
        String[] parts2 = "a,b,,c".split(",", -1);  // Manter strings vazias no final
        System.out.println(parts2.length);  // 4
    }
}

❓ Perguntas Frequentes

P: Regex é difícil de lembrar—o que devo fazer? R: Lembre-se dos padrões comuns: \d \w \s . * + ? [] (). Para padrões complexos, consulte a documentação.

P: Qual biblioteca JSON devo usar em Java? R: Jackson é a mais popular. Gson também é boa. Para cenários simples, a análise manual funciona.

P: Como é o desempenho do regex? R: Regex simples tem bom desempenho. Regex complexos podem ter problemas de desempenho. Evite muita retrocesso.

📖 Resumo

Regex é usada para correspondência, busca e substituição de strings
Pattern e Matcher são classes principais para regex Java
JSON é um formato leve de troca de dados
Jackson é a biblioteca JSON mais popular do Java

📝 Exercícios

Validação de email: Escreva um método para validar formato de email
Extração de texto: Extraia todos os links de um HTML
Análise JSON: Analise uma string JSON e extraia campos específicos

Próxima Lição

Na próxima lição, aprenderemos sobre Projeto Abrangente — construindo um projeto Java completo.