Escrever valores por extenso pode ser uma necessidade no desenvolvimento de aplicações, e isso seria bastante trabalhoso se tivesse que fazer manualmente.

Por isso, vou mostrar duas formas de fazer isso de maneira simples e prática, sem se utilizar de muito esforço.

Valor por extenso utilizando uma classe utilitária

O primeiro exemplo para escrever valores por extenço é utilizando uma classe, que inclusive também utilizo aqui nos projetos, onde basta cópiar e colocar a classe java em seu projeto e utilizar os métodos.

Veja a classe:

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
   
@SuppressWarnings("unchecked")  
public class Extenso {  
    
	private ArrayList nro;  
    private BigInteger num;  
   
    private String Qualificadores[][] = {  
          {"Centavo", "Centavos"},  
          {"", ""},  
          {"Mil", "Mil"},  
          {"Milhão", "Milhões"},  
          {"Bilhão", "Bilhões"},  
          {"Trilhão", "Trilhões"},  
          {"Quatrilhão", "Quatrilhões"},  
          {"Quintilhão", "Quintilhões"},  
          {"Sextilhão", "Sextilhões"},  
          {"Septilhão", "Septilhões"}  
          };  
    private String Numeros[][] = {  
          {"Zero", "Um", "Dois", "Três", "Quatro", "Cinco", "Seis", "Sete", "Oito", "Nove", "Dez",  
          "Onze", "Doze", "Treze", "Quatorze", "Quinze", "Desesseis", "Desessete", "Dezoito", "Desenove"},  
          {"Vinte", "Trinta", "Quarenta", "Cinquenta", "Sessenta", "Setenta", "Oitenta", "Noventa"},  
          {"Cem", "Cento", "Duzentos", "Trezentos", "Quatrocentos", "Quinhentos", "Seiscentos",  
          "Setecentos", "Oitocentos", "Novecentos"}  
          };  
   
   
    public Extenso() {  
       nro = new ArrayList();  
    }  
   
    public Extenso(BigDecimal dec) {  
       this();  
       setNumber(dec);  
    }  

    public Extenso(double dec) {  
       this();  
       setNumber(dec);  
    }  
   
    public void setNumber(BigDecimal dec) {  
       // Converte para inteiro arredondando os centavos  
       num = dec.setScale(2, BigDecimal.ROUND_HALF_UP).multiply(BigDecimal.valueOf(100)).toBigInteger(); 
       // Adiciona valores  
       nro.clear();  
       if (num.equals(BigInteger.ZERO)) {  
          // Centavos  
          nro.add(new Integer(0));  
          // Valor  
          nro.add(new Integer(0));  
       }  
       else {  
          // Adiciona centavos  
          addRemainder(100);  
          // Adiciona grupos de 1000  
          while (!num.equals(BigInteger.ZERO)) {  
             addRemainder(1000);  
          }  
       }  
    }  
   
    public void setNumber(double dec) {  
       setNumber(new BigDecimal(dec));  
   }  
   
    public void show() {  
       Iterator valores = nro.iterator();  
       while (valores.hasNext()) {  
          System.out.println(((Integer) valores.next()).intValue());  
       }  
       System.out.println(toString());  
    }
   
    public String toString() {  
       StringBuffer buf = new StringBuffer();    
       //int numero = ((Integer) nro.get(0)).intValue();  
       int ct;  
  
       for (ct = nro.size() - 1; ct > 0; ct--) {  
          // Se ja existe texto e o atual não é zero  
          if (buf.length() > 0 && ! ehGrupoZero(ct)) {  
             buf.append(" e ");  
          }  
          buf.append(numToString(((Integer) nro.get(ct)).intValue(), ct));  
       }  
       if (buf.length() > 0) {  
          if (ehUnicoGrupo())  
             buf.append(" de ");  
          while (buf.toString().endsWith(" "))  
            buf.setLength(buf.length()-1);  
          if (ehPrimeiroGrupoUm())  
             //buf.insert(0, "h");  
          buf.insert(0, "");
          if (nro.size() == 2 && ((Integer)nro.get(1)).intValue() == 1) {  
             buf.append(" real");  
          } else {  
             buf.append(" reais");  
          }  
          if (((Integer) nro.get(0)).intValue() != 0) {  
             buf.append(" e ");  
          }  
       }  
       if (((Integer) nro.get(0)).intValue() != 0) {  
          buf.append(numToString(((Integer) nro.get(0)).intValue(), 0));  
       }  
       return buf.toString();  
    }  
   
    private boolean ehPrimeiroGrupoUm() {  
       if (((Integer)nro.get(nro.size()-1)).intValue() == 1)  
          return true;  
       return false;  
    }  
      
    private void addRemainder(int divisor) {  
       // Encontra newNum[0] = num modulo divisor, newNum[1] = num dividido divisor  
       BigInteger[] newNum = num.divideAndRemainder(BigInteger.valueOf(divisor));  
       // Adiciona modulo  
       nro.add(new Integer(newNum[1].intValue()));  
       // Altera numero  
       num = newNum[0];  
    }  
   
    private boolean ehUnicoGrupo() {  
       if (nro.size() <= 3)  
          return false;  
       if (!ehGrupoZero(1) && !ehGrupoZero(2))  
          return false;  
       boolean hasOne = false;  
       for(int i=3; i < nro.size(); i++) {  
          if (((Integer)nro.get(i)).intValue() != 0) {  
             if (hasOne)  
                return false;  
             hasOne = true;  
          }  
       }  
       return true;  
    }  
   
    boolean ehGrupoZero(int ps) {  
       if (ps == nro.size())  
          return true;  
       return ((Integer)nro.get(ps)).intValue() == 0;  
    }  
    
    private String numToString(int numero, int escala) {  
       int unidade = (numero % 10);  
       int dezena = (numero % 100); //* nao pode dividir por 10 pois verifica de 0..19  
       int centena = (numero / 100);  
       StringBuffer buf = new StringBuffer();  
   
       if (numero != 0) {  
          if (centena != 0) {  
             if (dezena == 0 && centena == 1) {  
                buf.append(Numeros[2][0]);  
             }  
             else {  
                buf.append(Numeros[2][centena]);  
             }  
          }  
          if ((buf.length() > 0) && (dezena != 0)) {  
             buf.append(" e ");  
          }  
          if (dezena > 19) {  
            dezena /= 10;  
             buf.append(Numeros[1][dezena - 2]);  
             if (unidade != 0) {  
                buf.append(" e ");  
                buf.append(Numeros[0][unidade]);  
             }  
          }  
          else if (centena == 0 || dezena != 0) {  
             buf.append(Numeros[0][dezena]);  
          }  
          buf.append(" ");  
          if (numero == 1) {  
             buf.append(Qualificadores[escala][0]);  
          }  
          else {  
             buf.append(Qualificadores[escala][1]);  
          }  
       }  
       return buf.toString();  
    }   
 }  

Para utilizar a classe para gerar valores por extenso em java, basta fazer o seguinte:

public static void main(String args[]) {
   Double valor = 120.35;
   System.out.println( new Extenso(valor).toString() );
}

O resultado será o seguinte:

Cento e Vinte reais e Trinta e Cinco Centavos

A vantagem de utilizar esta classe é que você pode alterar os nomes para outras linguagens e utilizar em qualquer idioma, mas se quiser outra opção para gerar valores por extenso em java, vou deixar mais uma dica.

Utilizando um biblioteca java para gerar valores por extenso

Este projeto está no github é um projeto simples mas funcional. O nome da biblioteca é PorExtenso.

Segundo o próprio autor da biblioteca, "PorExtenso foi desenvolvida para escrever valores monetários por extenso automaticamente e pode escrever valores da ordem de setilhões."

A url do projeto no github é: https://github.com/mcrisc/porextenso

O objetivo da biblioteca é gerar expressões em português gramaticalmente correto, para que possam ser usadas em documentos formais, como contratos.

Para utilizar a biblioteca, veja o código:

CurrencyWriter cw = CurrencyWriter.getInstance();

String extenso = cw.write(new BigDecimal("234.89"));
System.out.println(extenso);

extenso = cw.write(new BigDecimal("130000000000"));
System.out.println(extenso);

O resultado será:

duzentos e trinta e quatro reais e oitenta e nove centavos
cento e trinta bilhões de reais

Qualquer dúvida deixe nós comentários.

Não esqueca de deixar suas dúvidas nos comentários e compartilhar este post.