feed twitter facebook LinkedIn facebook

Java » Convertir un número a texto con Java

abril 8, 2012 por Víctor Cuervo 3 Comentarios Imprimir Imprimir

Vamos a ver como construir un método con Java al cual le pasemos un número de tres dígitos: unidades, decenas y centenas y nos lo transforme a texto. Es decir, el 534 nos lo transforme en "quinientos treinta y cuatro".

Lo primero será crear métodos de apoyo. El primer método de apoyo es el que dado una unidad nos la transforma en texto.

  1. public static String unidadEnTexto(int iNumero){
  2. // Método que dado un número me lo devuelve en texto
  3. switch(iNumero){
  4. case 1:
  5. return "uno";
  6. case 2:
  7. return "dos";
  8. case 3:
  9. return "tres";
  10. case 4:
  11. return "cuatro";
  12. case 5:
  13. return "cinco";
  14. case 6:
  15. return "seis";
  16. case 7:
  17. return "siete";
  18. case 8:
  19. return "ocho";
  20. case 9:
  21. return "nueve";
  22. case 0:
  23. return "cero";
  24. default:
  25. return "";
  26. }
  27. }

El siguiente será el de las decenas. Es decir, le pasaremos un número que represente las decenas y nos devolverá el texto. Si le pasamos un 2 nos devolverá "veinte".

  1. public static String decenaEnTexto(int iDecena){
  2. switch (iDecena){
  3. case 1:
  4. return "diez";
  5. case 2:
  6. return "veinte";
  7. case 3:
  8. return "treinta";
  9. case 4:
  10. return "cuarenta";
  11. case 5:
  12. return "cincuenta";
  13. case 6:
  14. return "sesenta";
  15. case 7:
  16. return "setenta";
  17. case 8:
  18. return "ochenta";
  19. case 9:
  20. return "noventa";
  21. default:
  22. return "";
  23. }
  24. }

Todas las decenas las podemos montar con el texto de la decena y el texto de la unidad, añadiendo un "y" en medio. Así 22 sería "veinte y dos". Hay un caso especial a tener en cuenta y este es el de las decenas del diez. Así que para ese caso nos montamos otro método de apoyo.

  1. public static String decenas(int iDecena){
  2. switch (iDecena){
  3. case 11:
  4. return "once";
  5. case 12:
  6. return "doce";
  7. case 13:
  8. return "trece";
  9. case 14:
  10. return "catorce";
  11. case 15:
  12. return "quince";
  13. case 16:
  14. return "dieciseis";
  15. case 17:
  16. return "diecisiete";
  17. case 18:
  18. return "dieciocho";
  19. case 19:
  20. return "diecinueve";
  21. default:
  22. return "";
  23. }
  24. }

Y lo último igual para las centenas. Si bien es verdad que aquí solo se nos devolverá el relativo a los cientos, quinientos y novecientos. Ya que para el testo de centenas lo podemos montar mediante la unidad y añadiendo el sufijo cientos. Así tendremos dos-cientos, tres-cientos,...

  1. public static String centenaEnTexto(int iCentena){
  2. switch (iCentena){
  3. case 1:
  4. return "ciento";
  5. case 5:
  6. return "quinientos";
  7. case 9:
  8. return "novecientos";
  9. default:
  10. return "";
  11. }
  12. }

Ahora solo nos queda desmontar el número e ir llamando a las funciones de apoyo necesarias. Para ir obteniendo por dígitos nos apoyamos en el módulo y división de 10. Ya que el módulo nos deja el dígito y la división el resto del número.

Así, para las unidades sería:

  1. int iUnidad = iNumero%10;
  2. iNumero = iNumero/10;
  3. sTexto = unidadEnTexto(iUnidad);

La conversión de la unidad ha sido sencilla ya que solo hemos tenido que llamar al método unidadEnTexto.

Vamos con las decenas, para obtener la decena el mismo mecanismo que antes.

  1. int iDecena = iNumero%10;
  2. iNumero = iNumero/10;
  3.  
  4. if ((iUnidad==0) && (iDecena>0))
  5. sTexto = decenaEnTexto(iDecena);
  6. else if (iDecena==1)
  7. sTexto = decenas(10+iUnidad);
  8. else if (iDecena > 1)
  9. sTexto = decenaEnTexto(iDecena) + " y " + sTexto;

Aqui tenemos tres casos.

  • Si la unidad era un cero, pedimos la decena y será el texto único.
  • Si la decena empieza por uno, caso especial y por lo tantto llamamos al método de las decenas.
  • Otros casos componemos con la decena y la unidad juntas con un "y".

El último caso, las centenas.

  1. int iCentena = iNumero%10;
  2.  
  3. if ((iCentena!=1) && (iCentena!=5) && (iCentena!=9) && (iCentena!=0))
  4. sTexto = unidadEnTexto(iCentena) + "cientos" + " " + sTexto;
  5. else if ((iCentena==1) || (iCentena==5) || (iCentena==9))
  6. sTexto = centenaEnTexto(iCentena) + " " + sTexto;

En este caso solo hay el dilema del 1, 5 y 9. Así que un if y solucionado. El resto de las centenas las montamos con la unidad en texto más el texto "cientos".

Así, finalmente, hemos dejado en sTexto el número convertido a texto con Java.

Descargar el Codigo
Descargar el código
Error en el Codigo
Error en el código
Foro sobre Java
Foro sobre Java
tags: , , , , , , , ,

Artículos relacionados:

3 comentarios »

RSS feed para los comentarios de esta entrada. TrackBack URI

  1. kelcom
    febrero 24, 2013 #

    aca les dejo el algoritmo URL: convetirnumerosaletras.blogspo­t.com/2013/02/algoritmo.html

Deja un comentario

XHTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

*