Calculando Dígito Verificador de um CPF

Programação Java
, ,
#1

Boa Tarde, tudo bem ?
Estou fazendo esse pequeno programa, mas eu não consigo somar os numeros depois do resultado da multiplicaçççcao do CPF com o multiplicador, Por favor leia o exercício abaixo.

Calculando Dígito Verificador de um CPF.

O CPF (Cadastro de Pessoas Físicas) é composto por 11 dígitos ao todo, porém os 2 últimos dígitos são calculados, essa informação serve para determinarmos por exemplo, se um cpf é ou não válido.

Para calcular um CPF existem alguns passo que precisam ser seguidos, veja abaixo:

Vamos tomar como exemplo o CPF fictício 728.316.240-29, para calcular seus DVs vamos fazer as seguintes operações.

Calculando o DV 1

|Dígito do CPF|7|2|8|3|1|6|2|4|0|DV1|
|Multiplicador|10|9|8|7|6|5|4|3|2||
|Resultado|70|18|64|21|6|30|8|12|0||

Agora deve-se somar os resultados

70+18+64+21+6+30+8+12+0= 229

Agora deve-se calcular o módulo de 229 por 11, sendo assim:
229 % 11 = 9

E por fim deve-se subtrair esse resultado de 11, ou seja:

11 - 9 = 2

Se o resultado da subtração for maior que 9, o dígito verificador é ZERO. Caso contrário, o dígito verificador é o resultado dessa subtração. Neste caso, o primeiro dígito verificador é 2.

E temos o primeiro dígito verificador

CPF 7 2 8 3 1 6 2 4 0 2

Agora devemos calcular o segundo dígito verificador da seguinte forma

|Dígito do CPF|7|2|8|3|1|6|2|4|0|2|
|Multiplicador|11|10|9|8|7|6|5|4|3|2|
|Resultado|77|20|72|24|7|36|10|16|0|4|

Agora deve-se somar os resultados

77+20+72+24+7+36+10+16+0+4=266

Agora deve-se calcular o módulo de 229 por 11, sendo assim:
266 % 11 = 2

E por fim deve-se subtrair esse resultado de 11, ou seja:

11 - 2 = 9

Se o resultado da subtração for maior que 9, o dígito verificador é ZERO. Caso contrário, o dígito verificador é o resultado dessa subtração. Neste caso, o primeiro dígito verificador é 9.

E temos o segundo dígito verificador

CPF 7 2 8 3 1 6 2 4 0 2 9

Uma vez entendido o problema escreva um programa que dados os 9 primeiros dígitos de um CPF calcule os dois dígitos verificadores.

MEU CODIGO ESTA ASSIM:
public class CalculandoDigitoCPF
{
public static void main(String[] args)
{
int[] CPF = {7,2,8,3,1,6,2,4,0};
int[] multiplicador = {10,9,8,7,6,5,4,3,2};
int Dv1 = 1;
for (int i = 0; i < Dv1; i++)
{
Dv1 = CPF[i] * multiplicador[i];
System.out.print(Dv1+ " ");
}
}
}
VLW pela forççca.

#2

Antes de mais nada, sempre use o botão de de formatação de código </> confome informado em Como Fazer Uma Boa Pergunta, pois isso ajuda na leitura do código.

Exemplo de código:

import java.util.Scanner;

public class VerificarCPF {
	private int numeracao[] = new int[11];
	
	private String lerCPF(){
		String cpfBruto;
		Scanner leitor = new Scanner(System.in);
		
		System.out.print("Informe os 9 primeiros dígitos do CPF: ");
		cpfBruto = leitor.next();
		
		return cpfBruto;
	}
	
	private void obterNumeracaoCPF(String cpf){
		short contador = 0;
		
		if(cpf.length() == 9){
			for(short i = 0; i < cpf.length(); i++){
				if(Character.isDigit(cpf.charAt(i))){
					numeracao[contador++] = Character.digit(cpf.charAt(i), 10);
				}
			}
		}else{
			System.out.print("Informe os 9 primeiros dígitos do CPF.");
		}
	}
	
	private int obterSomatorio1(){
		int somatorio = 0;
		int[] multiplicadores = {10, 9, 8, 7, 6, 5, 4, 3, 2};
		
		for(short i = 0; i < multiplicadores.length; i++){
			somatorio += (numeracao[i] * multiplicadores[i]);
		}
		
		return somatorio;
	}
	
	private int obterSomatorio2(){
		int somatorio = 0;
		int[] multiplicadores = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
		
		for(short i = 0; i < multiplicadores.length; i++){
			somatorio += (numeracao[i] * multiplicadores[i]);
		}
		
		return somatorio;
	}
	
	private void obterDiv(int soma, int t){
		int modulo;
		int resto;
		
		modulo = soma % 11;
		resto = 11 - modulo;
		
		if(resto > 9){
			if(t == 9)
				numeracao[9] = 0;
			
			else if(t == 10)
				numeracao[10] = 0;
			
		}else{
			if(t == 9)
				numeracao[9] = resto;
			
			else if(t == 10)
				numeracao[10] = resto;
		}
	}
	
	public static void main(String[] args){
		VerificarCPF verificarCPF = new VerificarCPF();
		verificarCPF.obterNumeracaoCPF(verificarCPF.lerCPF());
		verificarCPF.obterDiv(verificarCPF.obterSomatorio1(), 9);
		verificarCPF.obterDiv(verificarCPF.obterSomatorio2(), 10);
		
		
		System.out.print("Div: " + verificarCPF.numeracao[9] + verificarCPF.numeracao[10]);
	}
}

Rodando…
image

#3

Agradeççco pela sua ajuda.
Muito obrigado, um abaco, meu amigo.

#4

Há algum tempo criei uma classe utilitária Documentos que disponibiliza métodos estáticos para:

  • Verificar se determinado CPF ou CNPJ é válido;
  • Gerar CPF e CNPJ de forma aleatória, um recurso útil no desenvolvimento de testes.

Exemplo de como gerar um CPF aleatoriamente e como verificar se o CPF é válido:

String cpf = Documentos.cpfAleatorio(); // poderia inicializar com qualquer outro CPF
System.out.print("O CPF " + cpf + " é ");
if (Documentos.cpfValido(cpf)) {
    System.out.println("válido");
} else {
    System.out.println("inválido");
}

Exemplo de como gerar um CNPJ aleatoriamente e como verificar se o CNPJ é válido:

String cnpj = Documentos.cnpjAleatorio(); // poderia inicializar com qualquer outro CNPJ
System.out.print("O CNPJ " + cnpj + " é ");
if (Documentos.cnpjValido(cnpj)) {
    System.out.println("válido");
} else {
    System.out.println("inválido");
}

Código fonte:

import java.util.Random;

/**
 * Classe utilitária com métodos estáticos para:<br>
 * <ul>
 * <li>Verificar se o CPF informado é válido: {@link Documentos#cpfValido(String)};</li>
 * <li>Gerar um CPF aleatório válido: {@link Documentos#cpfAleatorio()};</li>
 * <li>Verificar se o CNPJ informado é válido: {@link Documentos#cnpjValido(String)};</li>
 * <li>Gerar um CNPJ aleatório válido: {@link Documentos#cnpjAleatorio()}.</li>
 * </ul>
 * 
 * @author <a href="https://github.com/staroski">Ricardo Artur Staroski</a>
 *
 */
public final class Documentos {

    private static final int TAMANHO_CPF = 11;
    private static final int TAMANHO_CNPJ = 14;

    private static final int[] PESOS_CPF = { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
    private static final int[] PESOS_CNPJ = { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };

    /**
     * Gera um CNPJ aleatório válido.
     * 
     * @return O CNPJ gerado.
     * 
     * @see Documentos#cpfValido(String)
     * @see Documentos#cpfAleatorio()
     * @see Documentos#cnpjValido(String)
     */
    public static String cnpjAleatorio() {
        String digitos = digitos(TAMANHO_CNPJ - 2);
        String verificador1 = verificador(digitos, PESOS_CNPJ);
        String verificador2 = verificador(digitos + verificador1, PESOS_CNPJ);
        return digitos + verificador1 + verificador2;
    }

    /**
     * Verifica se o CNPJ informado é válido.
     * 
     * @param cnpj
     *            O CNPJ a ser verificado.
     * 
     * @return <code>true</code> se o CNPJ informado for válido e <code>false</code> caso contrário.
     * 
     * @see Documentos#cpfValido(String)
     * @see Documentos#cpfAleatorio()
     * @see Documentos#cnpjAleatorio()
     */
    public static boolean cnpjValido(final String cnpj) {
        if (cnpj == null) {
            return false;
        }
        if (cnpj.length() != TAMANHO_CNPJ) {
            return false;
        }
        if (cnpj.matches(cnpj.charAt(0) + "{" + TAMANHO_CNPJ + "}")) {
            return false;
        }
        String digitos = cnpj.substring(0, TAMANHO_CNPJ - 2);
        String verificador1 = verificador(digitos, PESOS_CNPJ);
        String verificador2 = verificador(digitos + verificador1, PESOS_CNPJ);
        return (digitos + verificador1 + verificador2).equals(cnpj);
    }

    /**
     * Gera um CPF aleatório válido.
     * 
     * @return O CPF gerado.
     * 
     * @see Documentos#cpfValido(String)
     * @see Documentos#cnpjValido(String)
     * @see Documentos#cnpjAleatorio()
     */
    public static String cpfAleatorio() {
        String digitos = digitos(TAMANHO_CPF - 2);
        String verificador1 = verificador(digitos, PESOS_CPF);
        String verificador2 = verificador(digitos + verificador1, PESOS_CPF);
        return digitos + verificador1 + verificador2;
    }

    /**
     * Verifica se o CPF informado é válido.
     * 
     * @param cpf
     *            O CPF a ser verificado.
     * 
     * @return <code>true</code> se o CPF informado for válido e <code>false</code> caso contrário.
     * 
     * @see Documentos#cpfAleatorio()
     * @see Documentos#cnpjValido(String)
     * @see Documentos#cnpjAleatorio()
     */
    public static boolean cpfValido(final String cpf) {
        if (cpf == null) {
            return false;
        }
        if (cpf.length() != TAMANHO_CPF) {
            return false;
        }
        if (cpf.matches(cpf.charAt(0) + "{" + TAMANHO_CPF + "}")) {
            return false;
        }
        String digitos = cpf.substring(0, TAMANHO_CPF - 2);
        String verificador1 = verificador(digitos, PESOS_CPF);
        String verificador2 = verificador(digitos + verificador1, PESOS_CPF);
        return (digitos + verificador1 + verificador2).equals(cpf);
    }

    /**
     * Utilizado internamente para gerar determinada quantidade de dígitos.
     */
    private static String digitos(int quantidade) {
        StringBuilder digitos = new StringBuilder();
        Random random = new Random();
        for (int contador = 0; contador < quantidade; contador++) {
            digitos.append(random.nextInt(10)); // gerar um dígito entre 0 e 9
        }
        return digitos.toString();
    }

    /**
     * Utilizado internamente para calcular um dígito verificador.
     */
    private static String verificador(String digitos, int[] pesos) {
        int soma = 0;
        int qtdPesos = pesos.length;
        int qtdDigitos = digitos.length();
        for (int posicao = qtdDigitos - 1; posicao >= 0; posicao--) {
            int digito = Character.getNumericValue(digitos.charAt(posicao));
            soma += digito * pesos[qtdPesos - qtdDigitos + posicao];
        }
        soma = 11 - soma % 11;
        return String.valueOf(soma > 9 ? 0 : soma);
    }

    // Construtor privado, não faz sentido instanciar esta classe
    private Documentos() {}
}