Código De Número Por Extenso Em Java

Introdução

No post anterior [1], vimos um algoritmo geral para a escrita em extenso. Esse post de hoje nada mais é que esse algoritmo implementado em Java.

Para saber como escrever sua própria versão do algoritmo, visite o link [1] para ter acesso ao algoritmo geral da escrita por extenso.

O código

/*
 * Classe que descreve o algoritmo geral de escrita por extenso.
 *
 * Autor: Marcos Paulo Ferreira (Daemonio)
 * Contato: undefinido gmail com
 * https://daemoniolabs.wordpress.com
*/
public class dExtenso {

   private String trioextenso[][]={
       {"dummy", "um", "dois", "três", "quatro", "cinco", "seis", "sete",
        "oito", "nove"},
       {"dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis",
        "dezessete", "dezoito", "dezenove"},
       {"dummy", "dummy", "vinte", "trinta", "quarenta",
        "cinquenta", "sessenta", "setenta", "oitenta", "noventa"},
       {"dummy", "cento", "duzentos", "trezentos",
        "quatrocentos", "quinhentos", "seiscentos",
        "setecentos", "oitocentos", "novecentos"}
    };

   private String classextenso[] ={
               "dummy", "mil", "milh", "bilh", "trilh", "quatrilh",
               "quintilh", "sextilh", "septilh", "octilh",
               "nonilh", "decilh", "undecilh", "duodecilh",
               "tredecilh", "quatordecilh", "quindecilh",
               "sexdecilh", "setedecilh", "octodecilh",
               "novedecilh", "vigesilh" };

   /* Adiciona conjunção 'e' no extenso de um trio. */
   public String adicionar_conjuncao_e(String saida) {

       /* Retira espaço inicial */
       if(saida.charAt(0) == ' ') saida = saida.substring(1) ;

       /* Retira espaço final */
       if(saida.charAt(saida.length()-1) == ' ')
           saida = saida.substring(0, saida.length()-1) ;

       /* Troca " " por " e " */
       saida = saida.replaceAll(" ", " e ") ;

       return saida ;
   }

   /* Recebe um trio da forma cdu e o transforma
    * em extenso.
    */
   public String escrever_trio_extenso(String trio) {
       String saida="" ;
       char u, d, c;

       u=trio.charAt(2);
       d=trio.charAt(1);
       c=trio.charAt(0);

       if(trio.equals("100")) saida="cem" ;
       else if(trio.equals("000")) saida="zero" ;
       else {
           if(c!='0') saida=trioextenso[3][c-'0'];
           if(d=='1') saida=saida+" "+trioextenso[1][u-'0'];
           else {
               if(d!='0') saida=saida+" "+trioextenso[2][d-'0'];
               if(u!='0') saida=saida+" "+trioextenso[0][u-'0'] ;
           }
       }

       saida = adicionar_conjuncao_e(saida) ;

       return saida ;
   }

   /* Retorna um vetor de Strings sendo cada elemento
    * um trio. A ordem dos trios está inversa em
    * relação ao original.
    */
   private String[] getTriosAoContrario(String numero) {
       String[] vetorTrios ;
       int t ;

       t=numero.length()/3 ;
       vetorTrios = new String[t] ;

       for(String s : numero.replaceAll("...", "$0,").split(",")) {
           vetorTrios[t-1]=s; t-- ;
       }

       return vetorTrios ;
   }

   private boolean nao_e_ultimo_trio(String[] vetorTrios, int contador) {
       return (vetorTrios.length != contador+1) ;
   }

   private boolean trio_a_esquerda_eq_zero(String[] vetorTrios, int contador) {
       return (vetorTrios[contador+1].equals("000")) ;
   }

    public String getExtenso(String numero) {
        String saida = "", extensoFinal = "";
        String[] vetorTrios;
        int contador = 0;
        int t ;

        /* Padding: Garante que a quantidade de alg.
         * do número seja multipla de três.
         */
        t = numero.length() % 3;
        if (t == 1) {
            numero = "00" + numero;
        } else if (t == 2) {
            numero = "0" + numero;
        }

        /* Número zero. */
        if(numero.equals("000")) return "zero" ;

        vetorTrios = getTriosAoContrario(numero);

        /* Para cada trio na ordem inversa ... */
        for (String trio : vetorTrios) {
            if (!trio.equals("000")) {
                saida = escrever_trio_extenso(trio);
                /* Obtém a classe. */
                if (contador > 0) {
                    saida = saida + " " + classextenso[contador];
                }
                /* Plural das classes. */
                if (contador > 1) {
                    if (Integer.parseInt(trio)>1) {
                        saida = saida + "ões";
                    } else {
                        saida = saida + "ão";
                    }
                }

                /* Junção dos extensos. */
                if (nao_e_ultimo_trio(vetorTrios, contador)) {
                    if (trio_a_esquerda_eq_zero(vetorTrios, contador)) {
                        saida = " e " + saida;
                    } else if (trio.charAt(0) != '0') {
                        saida = ", " + saida;
                    } else {
                        saida = " e " + saida;
                    }
                }
                extensoFinal = saida + extensoFinal;
            }
            contador++;
        }

        return extensoFinal;
    }
}

Uma classe de teste foi feita:

/* Classe Main de teste */
import java.util.Random;

public class Main {

    public static void main(String[] args) {
        Random r = new Random();
        Integer i, n ;

        dExtenso e = new dExtenso() ;

        for(i=0; i < 10; i++) {
            /* Gera um número aleatório positivo. */
            n = r.nextInt() ;
            if(n < 0) n=-1*n ;

            /* Escreve por extenso o numero dado. Veja que
             * precisamos convertê-lo para string.
             */
            System.out.println(n + " : " + e.getExtenso(n.toString())) ;
        }
    }
}

A saída foi:

887437857 : oitocentos e oitenta e sete milhões, quatrocentos e trinta e sete mil, oitocentos e cinquenta e sete
1683304705 : um bilhão, seiscentos e oitenta e três milhões, trezentos e quatro mil, setecentos e cinco
688661022 : seiscentos e oitenta e oito milhões, seiscentos e sessenta e um mil e vinte e dois
316089246 : trezentos e dezesseis milhões e oitenta e nove mil, duzentos e quarenta e seis
331541220 : trezentos e trinta e um milhões, quinhentos e quarenta e um mil, duzentos e vinte
2110811689 : dois bilhões, cento e dez milhões, oitocentos e onze mil, seiscentos e oitenta e nove
1343716012 : um bilhão, trezentos e quarenta e três milhões, setecentos e dezesseis mil e doze
1224130646 : um bilhão, duzentos e vinte e quatro milhões, cento e trinta mil, seiscentos e quarenta e seis
1570259302 : um bilhão, quinhentos e setenta milhões, duzentos e cinquenta e nove mil, trezentos e dois
1977526118 : um bilhão, novecentos e setenta e sete milhões, quinhentos e vinte e seis mil, cento e dezoito

Ao se instanciar um objeto, o método getExtenso(String) estará disponível. Como visto, ele recebe um número na sua forma String e retorna esse número por extenso.

Se seu objetivo é obter o extenso em reais, então há uma solução simples para isso. Nesse caso, basta você quebrar o número original em dois, usando a vírgula como delimitador. Em seguida, você chama o método getExtenso() para cada uma dessas partes. Por fim, conecte as duas saídas com “real” ou “reais” e acrescente “centavo” ou “centavos” no fim, dependendo da situação.

Referências

[1] Número Por Extenso: Algoritmo Geral by Daemonio (Acessado em: Julho/2012)
https://daemoniolabs.wordpress.com/2012/06/24/numeros-por-extenso-algoritmo-geral/