Gerar CPF em Java: Função com Testes JUnit 5

Em muitos projetos Java, gerar CPF válido diretamente no código é necessário para popular fixtures, alimentar testes de integração e simular cenários em ambientes de homologação. A classe abaixo aplica o algoritmo de módulo 11 sobre nove dígitos aleatórios, encapsulando a lógica em um método estático pronto para uso com validador auxiliar.

Código

import java.util.Random;

public class CPFGenerator {

    private static final Random random = new Random();

    public static String generate() {
        int[] digits = new int[11];

        for (int i = 0; i < 9; i++) {
            digits[i] = random.nextInt(10);
        }

        // Primeiro dígito verificador
        int sum = 0;
        for (int i = 0; i < 9; i++) {
            sum += digits[i] * (10 - i);
        }
        int r = sum % 11;
        digits[9] = r < 2 ? 0 : 11 - r;

        // Segundo dígito verificador
        sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += digits[i] * (11 - i);
        }
        r = sum % 11;
        digits[10] = r < 2 ? 0 : 11 - r;

        StringBuilder sb = new StringBuilder(11);
        for (int d : digits) {
            sb.append(d);
        }
        return sb.toString();
    }

    public static boolean validate(String cpf) {
        String cleaned = cpf.replaceAll("[^\\d]", "");

        if (cleaned.length() != 11) {
            return false;
        }

        // Rejeita CPFs com todos os dígitos iguais
        if (cleaned.chars().distinct().count() == 1) {
            return false;
        }

        int[] digits = new int[11];
        for (int i = 0; i < 11; i++) {
            digits[i] = cleaned.charAt(i) - '0';
        }

        // Verifica primeiro dígito
        int sum = 0;
        for (int i = 0; i < 9; i++) {
            sum += digits[i] * (10 - i);
        }
        int r = sum % 11;
        int expected = r < 2 ? 0 : 11 - r;
        if (digits[9] != expected) {
            return false;
        }

        // Verifica segundo dígito
        sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += digits[i] * (11 - i);
        }
        r = sum % 11;
        expected = r < 2 ? 0 : 11 - r;
        return digits[10] == expected;
    }
}

Análise do código

O método generate() começa criando um array de 11 posições e preenchendo as nove primeiras com dígitos aleatórios obtidos via random.nextInt(10). Em seguida, aplica a fórmula do módulo 11 duas vezes: a primeira iteração percorre os nove dígitos base com pesos de 10 a 2 para obter o primeiro verificador, e a segunda percorre os dez dígitos (incluindo o verificador recém-calculado) com pesos de 11 a 2 para obter o segundo.

O método validate() funciona como espelho do gerador. Ele limpa a string de entrada removendo qualquer caractere não numérico, verifica se o resultado tem exatamente 11 dígitos e rejeita sequências onde todos os dígitos são iguais (como 11111111111), que passariam na conta matemática mas não são CPFs válidos. Depois recalcula os dois verificadores e os compara com os dígitos fornecidos.

A escolha de um int[] para armazenar os dígitos evita conversões repetidas entre char e int, mantendo o código legível e eficiente. O StringBuilder com capacidade pré-definida de 11 garante que a montagem da string final não exija realocações de buffer. A instância de Random é declarada como campo estático para ser reutilizada entre chamadas sucessivas.

Uso

public class Main {
    public static void main(String[] args) {
        String cpf = CPFGenerator.generate();
        System.out.println("CPF gerado: " + cpf);
        System.out.println("Válido: " + CPFGenerator.validate(cpf));
    }
}

Testes

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class CPFGeneratorTest {

    @Test
    void geradoDeveTer11Digitos() {
        String cpf = CPFGenerator.generate();
        assertEquals(11, cpf.length());
        assertTrue(cpf.matches("\\d{11}"));
    }

    @Test
    void geradoDeveSerValido() {
        String cpf = CPFGenerator.generate();
        assertTrue(CPFGenerator.validate(cpf));
    }

    @Test
    void multiplosGeradosDevemDiferir() {
        String cpf1 = CPFGenerator.generate();
        String cpf2 = CPFGenerator.generate();
        String cpf3 = CPFGenerator.generate();
        assertFalse(cpf1.equals(cpf2) && cpf2.equals(cpf3),
                "Três CPFs gerados consecutivamente não devem ser todos iguais");
    }
}

O primeiro teste garante que o CPF tem exatamente 11 caracteres numéricos. O segundo confirma que o CPF gerado é reconhecido como válido pelo próprio validador. O terceiro gera três CPFs e verifica que não são todos idênticos, o que confirmaria uma falha na aleatoriedade.

Veja também como validar CPF em Java com exemplos detalhados, ou volte à página inicial para gerar CPFs online.