Convertir Números a Letras en Java

Función completa

Copia este código en un archivo llamado NumeroALetras.java:

public class NumeroALetras {

    private static final String[] UNIDADES = {
        "", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete",
        "ocho", "nueve", "diez", "once", "doce", "trece", "catorce",
        "quince", "dieciséis", "diecisiete", "dieciocho", "diecinueve"
    };

    private static final String[] DECENAS = {
        "", "", "veinte", "treinta", "cuarenta", "cincuenta", "sesenta",
        "setenta", "ochenta", "noventa"
    };

    private static final String[] CENTENAS = {
        "", "ciento", "doscientos", "trescientos", "cuatrocientos",
        "quinientos", "seiscientos", "setecientos", "ochocientos",
        "novecientos"
    };

    public static String convertir(double numero) {
        long parteEntera = (long) numero;
        long parteDecimal = Math.round((numero - parteEntera) * 100);
        String resultado = convertirEntero(parteEntera);
        if (parteDecimal > 0) {
            resultado += " con " + parteDecimal + "/100";
        }
        return resultado;
    }

    private static String convertirEntero(long n) {
        if (n == 0) return "cero";
        if (n < 0) return "menos " + convertirEntero(-n);
        if (n == 100) return "cien";

        StringBuilder resultado = new StringBuilder();

        if (n >= 1_000_000) {
            long millones = n / 1_000_000;
            resultado.append(millones == 1
                ? "un millón "
                : convertirEntero(millones) + " millones ");
            n %= 1_000_000;
        }
        if (n >= 1_000) {
            long miles = n / 1_000;
            resultado.append(miles == 1
                ? "mil "
                : convertirEntero(miles) + " mil ");
            n %= 1_000;
        }
        if (n >= 100) {
            resultado.append(CENTENAS[(int) (n / 100)]).append(" ");
            n %= 100;
        }
        if (n >= 20) {
            if (n % 10 == 0) {
                resultado.append(DECENAS[(int) (n / 10)]);
            } else {
                resultado.append(DECENAS[(int) (n / 10)])
                         .append(" y ")
                         .append(UNIDADES[(int) (n % 10)]);
            }
        } else if (n > 0) {
            resultado.append(UNIDADES[(int) n]);
        }

        return resultado.toString().trim();
    }
}

Cómo usar

public class EjemploNumeroALetras {
    public static void main(String[] args) {
        System.out.println(NumeroALetras.convertir(0));           // cero
        System.out.println(NumeroALetras.convertir(15));          // quince
        System.out.println(NumeroALetras.convertir(100));         // cien
        System.out.println(NumeroALetras.convertir(150));         // ciento cincuenta
        System.out.println(NumeroALetras.convertir(1500));        // mil quinientos
        System.out.println(NumeroALetras.convertir(10000));       // diez mil
        System.out.println(NumeroALetras.convertir(100000));      // cien mil
        System.out.println(NumeroALetras.convertir(1000000));     // un millón
        System.out.println(NumeroALetras.convertir(2500000));     // dos millones quinientos mil
        System.out.println(NumeroALetras.convertir(15250.75));    // quince mil doscientos cincuenta con 75/100
        System.out.println(NumeroALetras.convertir(-500));        // menos quinientos
    }
}

Ejemplo en Spring Boot:

// En un servicio de facturación con Spring Boot
@Service
public class FacturaService {

    public String generarTextoFactura(double total) {
        String totalLetras = NumeroALetras.convertir(total);
        return "Son: " + totalLetras + " PESOS M.N.";
    }
}

Casos de prueba

Ejecuta estos casos para verificar que funciona (JUnit 5 o main()):

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

class NumeroALetrasTest {

    @Test void testCero() { assertEquals("cero", NumeroALetras.convertir(0)); }
    @Test void testUnidades() { assertEquals("cinco", NumeroALetras.convertir(5)); }
    @Test void testEspeciales() { assertEquals("quince", NumeroALetras.convertir(15)); }
    @Test void testDecenas() { assertEquals("treinta", NumeroALetras.convertir(30)); }
    @Test void testDecenasConY() { assertEquals("treinta y cinco", NumeroALetras.convertir(35)); }
    @Test void testCien() { assertEquals("cien", NumeroALetras.convertir(100)); }
    @Test void testCentenas() { assertEquals("quinientos", NumeroALetras.convertir(500)); }
    @Test void testMil() { assertEquals("mil", NumeroALetras.convertir(1000)); }
    @Test void testMilQuinientos() { assertEquals("mil quinientos", NumeroALetras.convertir(1500)); }
    @Test void testDiezMil() { assertEquals("diez mil", NumeroALetras.convertir(10000)); }
    @Test void testCienMil() { assertEquals("cien mil", NumeroALetras.convertir(100000)); }
    @Test void testMillon() { assertEquals("un millón", NumeroALetras.convertir(1000000)); }
    @Test void testDecimales() { assertEquals("mil quinientos con 50/100", NumeroALetras.convertir(1500.50)); }
    @Test void testNegativo() { assertEquals("menos quinientos", NumeroALetras.convertir(-500)); }
}

Decimales

Decimales a fracción sobre cien: NumeroALetras.convertir(15250.75) → «quince mil doscientos cincuenta con 75/100». Para más precisión:

// Para 3 decimales
long parteDecimal = Math.round((numero - parteEntera) * 1000);
if (parteDecimal > 0) {
    resultado += " con " + parteDecimal + "/1000";
}

// Para 4 decimales
long parteDecimal = Math.round((numero - parteEntera) * 10000);
if (parteDecimal > 0) {
    resultado += " con " + parteDecimal + "/10000";
}

Pesos mexicanos

Agrega «PESOS M.N.» al resultado:

public static String convertirMXN(double numero) {
    return convertir(numero) + " PESOS M.N.";
}

// Uso
System.out.println(NumeroALetras.convertirMXN(1500));      // mil quinientos PESOS M.N.
System.out.println(NumeroALetras.convertirMXN(15250.75));  // quince mil doscientos cincuenta con 75/100 PESOS M.N.
System.out.println(NumeroALetras.convertirMXN(1000000));   // un millón PESOS M.N.

Requisitos y compatibilidad

Java puro, compatible con Java 8, 11, 17, 21+. Sin dependencias externas. Funciona en NetBeans, Eclipse e IntelliJ IDEA. No necesitas modificar pom.xml ni build.gradle.