Como validar CNPJ alfanumérico em Java

Saber como validar CNPJ alfanumérico em Java é essencial para preparar seus sistemas antes de julho de 2026, quando a Receita Federal começa a emitir o novo CNPJ com letras nas 12 primeiras posições. Aqui você recebe uma classe utilitária pronta — com validação e cálculo dos dígitos verificadores — e ainda um exemplo de Bean Validation para Spring Boot.

O que muda no CNPJ alfanumérico

O novo formato, definido pela Instrução Normativa RFB nº 2.229/2024, mantém as 14 posições e a mesma máscara XX.XXX.XXX/XXXX-DD. A diferença é que as posições 1 a 12 (raiz + ordem) passam a aceitar letras maiúsculas A–Z além dos dígitos 0–9; os dois dígitos verificadores (posições 13–14) continuam numéricos. Os CNPJs numéricos atuais não mudam e seguem válidos, convivendo com os novos — seu código precisa aceitar os dois. Veja o panorama completo no nosso guia de implementação do CNPJ alfanumérico.

Validando CNPJ alfanumérico em Java

A classe abaixo é autocontida e sem dependências externas: usa apenas java.util.regex.Pattern. Ela normaliza a entrada (remove máscara e força maiúsculas), valida o formato, descarta a base zerada e confere os dígitos verificadores. Os pesos do módulo 11 são 5,4,3,2,9,8,7,6,5,4,3,2 para o primeiro DV e 6,5,4,3,2,9,8,7,6,5,4,3,2 para o segundo.

import java.util.regex.Pattern;

public final class CnpjAlfanumerico {
    private static final int[] PESO1 = {5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
    private static final int[] PESO2 = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
    private static final Pattern FORMATO = Pattern.compile("[A-Z0-9]{12}[0-9]{2}");

    private static String normalizar(String s) {
        return s.toUpperCase().replaceAll("[^A-Z0-9]", "");
    }

    private static int digito(String base, int[] pesos) {
        int soma = 0;
        for (int i = 0; i < base.length(); i++) {
            soma += (base.charAt(i) - 48) * pesos[i];
        }
        int resto = soma % 11;
        return resto < 2 ? 0 : 11 - resto;
    }

    public static String calcularDV(String base12) {
        int d1 = digito(base12, PESO1);
        int d2 = digito(base12 + d1, PESO2);
        return "" + d1 + d2;
    }

    public static boolean validar(String cnpj) {
        String c = normalizar(cnpj);
        if (!FORMATO.matcher(c).matches()) return false;
        if (c.substring(0, 12).matches("0{12}")) return false;
        return calcularDV(c.substring(0, 12)).equals(c.substring(12));
    }
}

Use assim: CnpjAlfanumerico.validar("12.ABC.345/01DE-35") retorna true, e CnpjAlfanumerico.calcularDV("12ABC34501DE") retorna "35". A classe é final e só expõe métodos estáticos — perfeita para reaproveitar em qualquer camada.

Calculando os dígitos verificadores

O método calcularDV recebe as 12 primeiras posições (a base) e devolve os dois dígitos. Internamente, digito() percorre cada caractere, converte para o valor numérico (charAt(i) - 48), multiplica pelo peso correspondente e soma tudo. O resto da divisão por 11 define o DV: se for menor que 2, o dígito é 0; caso contrário, é 11 - resto. O segundo dígito reaproveita a base concatenada com o primeiro DV, exatamente como no CNPJ numérico tradicional — só o conjunto de caracteres aceitos mudou.

Usando como Bean Validation no Spring Boot

Para validar campos de DTOs e entidades de forma declarativa, crie uma anotação @CnpjAlfanumerico e um ConstraintValidator que delega para o método estático acima. Assim a regra fica em um único lugar e o framework cuida do resto.

import jakarta.validation.Constraint;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import jakarta.validation.Payload;
import java.lang.annotation.*;

@Documented
@Constraint(validatedBy = CnpjAlfanumericoValidator.class)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface CnpjAlfanumerico {
    String message() default "CNPJ inválido";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

class CnpjAlfanumericoValidator
        implements ConstraintValidator<CnpjAlfanumerico, String> {
    @Override
    public boolean isValid(String valor, ConstraintValidatorContext ctx) {
        if (valor == null || valor.isBlank()) return true; // use @NotBlank à parte
        return CnpjAlfanumerico.validar(valor);
    }
}

Como testar

Use os vetores abaixo nos seus testes unitários (JUnit). Todos foram conferidos:

Perguntas frequentes

Posso continuar usando minha validação atual de CNPJ em Java?

Não inteiramente. A lógica do módulo 11 é a mesma, mas se o seu código usa apenas dígitos (por exemplo, Integer.parseInt ou regex \d sobre as 12 primeiras posições), ele vai rejeitar os novos CNPJs com letras. Troque a conversão por charAt(i) - 48 e aceite [A-Z0-9] na base.

Preciso mudar o tipo da coluna no banco e nos meus DTOs?

Sim. O CNPJ deve ser tratado como String em Java e como texto (VARCHAR(14) sem máscara) no banco. Campos int/long ou colunas inteiras quebram com letras. Normalize sempre para maiúsculas antes de gravar.

O exemplo de Spring Boot funciona com Jakarta Validation e javax?

O exemplo usa jakarta.validation (Spring Boot 3+). Em projetos legados com Spring Boot 2.x, troque os imports jakarta.* por javax.*; o restante da lógica permanece idêntico.

Veja também as versões irmãs deste tutorial: como validar CNPJ alfanumérico em C#/.NET e como validar CNPJ alfanumérico em Python.