Comment convertir un nombre en mots en java

Parce que vous ne pouvez pas avoir un algorithme général pour chaque locale, non. Vous devez implémenter votre propre algorithme pour chaque locale que vous prenez en charge.

** MODIFIER **

Juste pour le diable, j'ai joué jusqu'à ce que j'ai eu ce cours. Il ne peut pas afficher Long.MIN_VALUE en raison de restrictions de bits... mais je suppose qu'il pourrait être modifié et changer les types de valeur long en double pour les nombres décimaux ou encore plus grands Il peut afficher n'importe quel nombre jusqu'à 66 chiffres et 26 décimales utilisation d'une représentation de chaîne du nombre. Vous pouvez ajouter plus de ScaleUnit pour plus de décimales...

/**
 * This class will convert numeric values into an english representation
 * 
 * For units, see : http://www.jimloy.com/math/billion.htm
 * 
 * @author [email protected]
 */
public class NumberToWords {

    static public class ScaleUnit {
        private int exponent;
        private String[] names;
        private ScaleUnit(int exponent, String...names) {
            this.exponent = exponent;
            this.names = names;
        }
        public int getExponent() {
            return exponent;
        }
        public String getName(int index) {
            return names[index];
        }
    }

    /**
     * See http://www.wordiq.com/definition/Names_of_large_numbers
     */
    static private ScaleUnit[] SCALE_UNITS = new ScaleUnit[] {
        new ScaleUnit(63, "vigintillion", "decilliard"),
        new ScaleUnit(60, "novemdecillion", "decillion"),
        new ScaleUnit(57, "octodecillion", "nonilliard"),
        new ScaleUnit(54, "septendecillion", "nonillion"),
        new ScaleUnit(51, "sexdecillion", "octilliard"),
        new ScaleUnit(48, "quindecillion", "octillion"),
        new ScaleUnit(45, "quattuordecillion", "septilliard"),
        new ScaleUnit(42, "tredecillion", "septillion"),
        new ScaleUnit(39, "duodecillion", "sextilliard"),
        new ScaleUnit(36, "undecillion", "sextillion"),
        new ScaleUnit(33, "decillion", "quintilliard"),
        new ScaleUnit(30, "nonillion", "quintillion"),
        new ScaleUnit(27, "octillion", "quadrilliard"),
        new ScaleUnit(24, "septillion", "quadrillion"),
        new ScaleUnit(21, "sextillion", "trilliard"),
        new ScaleUnit(18, "quintillion", "trillion"),
        new ScaleUnit(15, "quadrillion", "billiard"),
        new ScaleUnit(12, "trillion", "billion"),
        new ScaleUnit(9, "billion", "milliard"),
        new ScaleUnit(6, "million", "million"),
        new ScaleUnit(3, "thousand", "thousand"),
        new ScaleUnit(2, "hundred", "hundred"),
        //new ScaleUnit(1, "ten", "ten"),
        //new ScaleUnit(0, "one", "one"),
        new ScaleUnit(-1, "tenth", "tenth"),
        new ScaleUnit(-2, "hundredth", "hundredth"),
        new ScaleUnit(-3, "thousandth", "thousandth"),
        new ScaleUnit(-4, "ten-thousandth", "ten-thousandth"),
        new ScaleUnit(-5, "hundred-thousandth", "hundred-thousandth"),
        new ScaleUnit(-6, "millionth", "millionth"),
        new ScaleUnit(-7, "ten-millionth", "ten-millionth"),
        new ScaleUnit(-8, "hundred-millionth", "hundred-millionth"),
        new ScaleUnit(-9, "billionth", "milliardth"),
        new ScaleUnit(-10, "ten-billionth", "ten-milliardth"),
        new ScaleUnit(-11, "hundred-billionth", "hundred-milliardth"),
        new ScaleUnit(-12, "trillionth", "billionth"),
        new ScaleUnit(-13, "ten-trillionth", "ten-billionth"),
        new ScaleUnit(-14, "hundred-trillionth", "hundred-billionth"),
        new ScaleUnit(-15, "quadrillionth", "billiardth"),
        new ScaleUnit(-16, "ten-quadrillionth", "ten-billiardth"),
        new ScaleUnit(-17, "hundred-quadrillionth", "hundred-billiardth"),
        new ScaleUnit(-18, "quintillionth", "trillionth"),
        new ScaleUnit(-19, "ten-quintillionth", "ten-trillionth"),
        new ScaleUnit(-20, "hundred-quintillionth", "hundred-trillionth"),
        new ScaleUnit(-21, "sextillionth", "trilliardth"),
        new ScaleUnit(-22, "ten-sextillionth", "ten-trilliardth"),
        new ScaleUnit(-23, "hundred-sextillionth", "hundred-trilliardth"),
        new ScaleUnit(-24, "septillionth","quadrillionth"),
        new ScaleUnit(-25, "ten-septillionth","ten-quadrillionth"),
        new ScaleUnit(-26, "hundred-septillionth","hundred-quadrillionth"),
    };

    static public enum Scale {
        SHORT,
        LONG;

        public String getName(int exponent) {
            for (ScaleUnit unit : SCALE_UNITS) {
                if (unit.getExponent() == exponent) {
                    return unit.getName(this.ordinal());
                }
            }
            return ""; 
        }
    }

    /**
     * Change this scale to support American and modern British value (short scale)
     * or Traditional British value (long scale)
     */
    static public Scale SCALE = Scale.SHORT; 


    static abstract public class AbstractProcessor {

        static protected final String SEPARATOR = " ";
        static protected final int NO_VALUE = -1;

        protected List<Integer> getDigits(long value) {
            ArrayList<Integer> digits = new ArrayList<Integer>();
            if (value == 0) {
                digits.add(0);
            } else {
                while (value > 0) {
                    digits.add(0, (int) value % 10);
                    value /= 10;
                }
            }
            return digits;
        }

        public String getName(long value) {
            return getName(Long.toString(value));
        }

        public String getName(double value) {
            return getName(Double.toString(value));
        }

        abstract public String getName(String value);
    }

    static public class UnitProcessor extends AbstractProcessor {

        static private final String[] TOKENS = new String[] {
            "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
            "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
        };

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            int offset = NO_VALUE;
            int number;
            if (value.length() > 3) {
                number = Integer.valueOf(value.substring(value.length() - 3), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 100;
            if (number < 10) {
                offset = (number % 10) - 1;
                //number /= 10;
            } else if (number < 20) {
                offset = (number % 20) - 1;
                //number /= 100;
            }

            if (offset != NO_VALUE && offset < TOKENS.length) {
                buffer.append(TOKENS[offset]);
            }

            return buffer.toString();
        }

    }

    static public class TensProcessor extends AbstractProcessor {

        static private final String[] TOKENS = new String[] {
            "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
        };

        static private final String UNION_SEPARATOR = "-";

        private UnitProcessor unitProcessor = new UnitProcessor();

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();
            boolean tensFound = false;

            int number;
            if (value.length() > 3) {
                number = Integer.valueOf(value.substring(value.length() - 3), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 100;   // keep only two digits
            if (number >= 20) {
                buffer.append(TOKENS[(number / 10) - 2]);
                number %= 10;
                tensFound = true;
            } else {
                number %= 20;
            }

            if (number != 0) {
                if (tensFound) {
                    buffer.append(UNION_SEPARATOR);
                }
                buffer.append(unitProcessor.getName(number));
            }

            return buffer.toString();
        }
    }

    static public class HundredProcessor extends AbstractProcessor {

        private int EXPONENT = 2;

        private UnitProcessor unitProcessor = new UnitProcessor();
        private TensProcessor tensProcessor = new TensProcessor();

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            int number;
            if (value.isEmpty()) {
                number = 0;
            } else if (value.length() > 4) {
                number = Integer.valueOf(value.substring(value.length() - 4), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 1000;  // keep at least three digits

            if (number >= 100) {
                buffer.append(unitProcessor.getName(number / 100));
                buffer.append(SEPARATOR);
                buffer.append(SCALE.getName(EXPONENT));
            }

            String tensName = tensProcessor.getName(number % 100);

            if (!tensName.isEmpty() && (number >= 100)) {
                buffer.append(SEPARATOR);
            }
            buffer.append(tensName);

            return buffer.toString();
        }
    }

    static public class CompositeBigProcessor extends AbstractProcessor {

        private HundredProcessor hundredProcessor = new HundredProcessor();
        private AbstractProcessor lowProcessor;
        private int exponent;

        public CompositeBigProcessor(int exponent) {
            if (exponent <= 3) {
                lowProcessor = hundredProcessor;
            } else {
                lowProcessor = new CompositeBigProcessor(exponent - 3);
            }
            this.exponent = exponent;
        }

        public String getToken() {
            return SCALE.getName(getPartDivider());
        }

        protected AbstractProcessor getHighProcessor() {
            return hundredProcessor;
        }

        protected AbstractProcessor getLowProcessor() {
            return lowProcessor;
        }

        public int getPartDivider() {
            return exponent;
        }

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            String high, low;
            if (value.length() < getPartDivider()) {
                high = "";
                low = value;
            } else {
                int index = value.length() - getPartDivider();
                high = value.substring(0, index);
                low = value.substring(index);
            }

            String highName = getHighProcessor().getName(high);
            String lowName = getLowProcessor().getName(low);

            if (!highName.isEmpty()) {
                buffer.append(highName);
                buffer.append(SEPARATOR);
                buffer.append(getToken());

                if (!lowName.isEmpty()) {
                    buffer.append(SEPARATOR);
                }
            }

            if (!lowName.isEmpty()) {
                buffer.append(lowName);
            }

            return buffer.toString();
        }
    }

    static public class DefaultProcessor extends AbstractProcessor {

        static private String MINUS = "minus";
        static private String UNION_AND = "and";

        static private String ZERO_TOKEN = "zero";

        private AbstractProcessor processor = new CompositeBigProcessor(63);

        @Override
        public String getName(String value) {
            boolean negative = false;
            if (value.startsWith("-")) {
                negative = true;
                value = value.substring(1);
            }

            int decimals = value.indexOf(".");
            String decimalValue = null;
            if (0 <= decimals) {
                decimalValue = value.substring(decimals + 1);
                value = value.substring(0, decimals);
            }

            String name = processor.getName(value);

            if (name.isEmpty()) {
                name = ZERO_TOKEN;
            } else if (negative) {
                name = MINUS.concat(SEPARATOR).concat(name); 
            }

            if (!(null == decimalValue || decimalValue.isEmpty())) {
                name = name.concat(SEPARATOR).concat(UNION_AND).concat(SEPARATOR)
                    .concat(processor.getName(decimalValue))
                    .concat(SEPARATOR).concat(SCALE.getName(-decimalValue.length()));
            }

            return name;
        }

    }

    static public AbstractProcessor processor;


    public static void main(String...args) {

        processor = new DefaultProcessor();

        long[] values = new long[] {
            0,
            4,
            10,
            12,
            100,
            108,
            299,
            1000,
            1003,
            2040,
            45213,
            100000,
            100005,
            100010,
            202020,
            202022,
            999999,
            1000000,
            1000001,
            10000000,
            10000007,
            99999999,
            Long.MAX_VALUE,
            Long.MIN_VALUE
        };

        String[] strValues = new String[] {
            "0001.2",
            "3.141592"
        };

        for (long val : values) {
            System.out.println(val + " = " + processor.getName(val) );
        }

        for (String strVal : strValues) {
            System.out.println(strVal + " = " + processor.getName(strVal) );
        }

        // generate a very big number...
        StringBuilder bigNumber = new StringBuilder();
        for (int d=0; d<66; d++) {
            bigNumber.append( (char) ((Math.random() * 10) + '0'));
        }
        bigNumber.append(".");
        for (int d=0; d<26; d++) {
            bigNumber.append( (char) ((Math.random() * 10) + '0'));
        }

        System.out.println(bigNumber.toString() + " = " + processor.getName(bigNumber.toString()));

    }

}

Et un exemple de sortie (pour le générateur de grand nombre aléatoire)

0 = zero
4 = four
10 = ten
12 = twelve
100 = one hundred
108 = one hundred eight
299 = two hundred ninety-nine
1000 = one thousand
1003 = one thousand three
2040 = two thousand fourty
45213 = fourty-five thousand two hundred thirteen
100000 = one hundred thousand
100005 = one hundred thousand five
100010 = one hundred thousand ten
202020 = two hundred two thousand twenty
202022 = two hundred two thousand twenty-two
999999 = nine hundred ninety-nine thousand nine hundred ninety-nine
1000000 = one million
1000001 = one million one
10000000 = ten million
10000007 = ten million seven
99999999 = ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-nine
9223372036854775807 = nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred seven
-9223372036854775808 = minus nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred eight
0001.2 = one and two tenth
3.141592 = three and one hundred fourty-one thousand five hundred ninety-two millionth
694780458103427072928672912656674465845126458162617425283733729646.85695031739734695391404376 = six hundred ninety-four vigintillion seven hundred eighty novemdecillion four hundred fifty-eight octodecillion one hundred three septendecillion four hundred twenty-seven sexdecillion seventy-two quindecillion nine hundred twenty-eight quattuordecillion six hundred seventy-two tredecillion nine hundred twelve duodecillion six hundred fifty-six undecillion six hundred seventy-four decillion four hundred sixty-five nonillion eight hundred fourty-five octillion one hundred twenty-six septillion four hundred fifty-eight sextillion one hundred sixty-two quintillion six hundred seventeen quadrillion four hundred twenty-five trillion two hundred eighty-three billion seven hundred thirty-three million seven hundred twenty-nine thousand six hundred fourty-six and eighty-five septillion six hundred ninety-five sextillion thirty-one quintillion seven hundred thirty-nine quadrillion seven hundred thirty-four trillion six hundred ninety-five billion three hundred ninety-one million four hundred four thousand three hundred seventy-six hundred-septillionth

ICU4J contient un joli support de numéro-sort. Les fichiers avec les "règles" peuvent être facilement édités, et ce n'est pas un problème d'ajouter d'autres langues (nous l'avons fait par exemple pour le polonais et le russe).

Je pense que cette solution n'est pas la meilleure, car il ne fonctionne que pour int, mais je pense que c'est idéal pour un débutant.

public class NumberWordConverter {
    public static final String[] units = {
            "", "one", "two", "three", "four", "five", "six", "seven",
            "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
            "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
    };

    public static final String[] tens = {
            "",        // 0
            "",        // 1
            "twenty",  // 2
            "thirty",  // 3
            "forty",   // 4
            "fifty",   // 5
            "sixty",   // 6
            "seventy", // 7
            "eighty",  // 8
            "ninety"   // 9
    };

    public static String convert(final int n) {
        if (n < 0) {
            return "minus " + convert(-n);
        }

        if (n < 20) {
            return units[n];
        }

        if (n < 100) {
            return tens[n / 10] + ((n % 10 != 0) ? " " : "") + units[n % 10];
        }

        if (n < 1000) {
            return units[n / 100] + " hundred" + ((n % 100 != 0) ? " " : "") + convert(n % 100);
        }

        if (n < 1000000) {
            return convert(n / 1000) + " thousand" + ((n % 1000 != 0) ? " " : "") + convert(n % 1000);
        }

        if (n < 1000000000) {
            return convert(n / 1000000) + " million" + ((n % 1000000 != 0) ? " " : "") + convert(n % 1000000);
        }

        return convert(n / 1000000000) + " billion"  + ((n % 1000000000 != 0) ? " " : "") + convert(n % 1000000000);
    }

    public static void main(final String[] args) {
        final Random generator = new Random();

        int n;
        for (int i = 0; i < 20; i++) {
            n = generator.nextInt(Integer.MAX_VALUE);

            System.out.printf("%10d = '%s'%n", n, convert(n));
        }

        n = 1000;
        System.out.printf("%10d = '%s'%n", n, convert(n));

        n = 2000;
        System.out.printf("%10d = '%s'%n", n, convert(n));

        n = 10000;
        System.out.printf("%10d = '%s'%n", n, convert(n));

        n = 11000;
        System.out.printf("%10d = '%s'%n", n, convert(n));

        n = 999999999;
        System.out.printf("%10d = '%s'%n", n, convert(n));

        n = Integer.MAX_VALUE;
        System.out.printf("%10d = '%s'%n", n, convert(n));
    }
}

Le test crée 20 nombres aléatoires jusqu'à Integer.MAX_VALUE et que certains qui savent être problématiques, en raison de 0, 10, etc.. Sortie:

   5599908 = 'five million five hundred ninety nine thousand nine hundred eight'
 192603486 = 'one hundred ninety two million six hundred three thousand four hundred eighty six'
1392431868 = 'one billion three hundred ninety two million four hundred thirty one thousand eight hundred sixty eight'
1023787010 = 'one billion twenty three million seven hundred eighty seven thousand ten'
1364396236 = 'one billion three hundred sixty four million three hundred ninety six thousand two hundred thirty six'
1511255671 = 'one billion five hundred eleven million two hundred fifty five thousand six hundred seventy one'
 225955221 = 'two hundred twenty five million nine hundred fifty five thousand two hundred twenty one'
1890141052 = 'one billion eight hundred ninety million one hundred forty one thousand fifty two'
 261839422 = 'two hundred sixty one million eight hundred thirty nine thousand four hundred twenty two'
 728428650 = 'seven hundred twenty eight million four hundred twenty eight thousand six hundred fifty'
 860607319 = 'eight hundred sixty million six hundred seven thousand three hundred nineteen'
 719753587 = 'seven hundred nineteen million seven hundred fifty three thousand five hundred eighty seven'
2063829124 = 'two billion sixty three million eight hundred twenty nine thousand one hundred twenty four'
1081010996 = 'one billion eighty one million ten thousand nine hundred ninety six'
 999215799 = 'nine hundred ninety nine million two hundred fifteen thousand seven hundred ninety nine'
2105226236 = 'two billion one hundred five million two hundred twenty six thousand two hundred thirty six'
1431882940 = 'one billion four hundred thirty one million eight hundred eighty two thousand nine hundred forty'
1991707241 = 'one billion nine hundred ninety one million seven hundred seven thousand two hundred forty one'
1088301563 = 'one billion eighty eight million three hundred one thousand five hundred sixty three'
 964601609 = 'nine hundred sixty four million six hundred one thousand six hundred nine'
      1000 = 'one thousand'
      2000 = 'two thousand'
     10000 = 'ten thousand'
     11000 = 'eleven thousand'
 999999999 = 'nine hundred ninety nine million nine hundred ninety nine thousand nine hundred ninety nine'
2147483647 = 'two billion one hundred forty seven million four hundred eighty three thousand six hundred forty seven'

J'espère que cela aide:)

/**

This Program will display the given number in words from 0 to 999999999

@author Manoj Kumar Dunna

Mail Id : [email protected]

**/  


import java.util.Scanner;

class NumberToString
{

    public enum hundreds {OneHundred, TwoHundred, ThreeHundred, FourHundred, FiveHundred, SixHundred, SevenHundred, EightHundred, NineHundred}
    public enum tens {Twenty, Thirty, Forty, Fifty, Sixty, Seventy, Eighty, Ninety}
    public enum ones {One, Two, Three, Four, Five, Six, Seven, Eight, Nine}
    public enum denom {Thousand, Lakhs, Crores}
    public enum splNums { Ten, Eleven, Twelve, Thirteen, Fourteen, Fifteen, Sixteen, Seventeen, Eighteen, Nineteen}
    public static String text = "";

    public static void main(String[] args) 
    {
        System.out.println("Enter Number to convert into words");
        Scanner sc = new Scanner(System.in);
        long num = sc.nextInt();
        int rem = 0;
        int i = 0;
        while(num > 0)
        {
            if(i == 0){
                rem = (int) (num % 1000);
                printText(rem);
                num = num / 1000;
                i++;
            }
            else if(num > 0)
            {
                rem = (int) (num % 100);
                if(rem > 0)
                    text = denom.values()[i - 1]+ " " + text;
                printText(rem);
                num = num / 100;
                i++;
            }
        }
        if(i > 0)
            System.out.println(text);
        else
            System.out.println("Zero");
    }

    public static void printText(int num)
    {
        if(!(num > 9 && num < 19))
        {
            if(num % 10 > 0)
                getOnes(num % 10);

            num = num / 10;
            if(num % 10 > 0)
                getTens(num % 10);

            num = num / 10;
            if(num > 0)
                getHundreds(num);
        }
        else
        {
            getSplNums(num % 10);
        }
    }

    public static void getSplNums(int num)
    {
        text = splNums.values()[num]+ " " + text;
    }

    public static void getHundreds(int num)
    {
        text = hundreds.values()[num - 1]+ " " + text;
    }

    public static void getTens(int num)
    {
        text = tens.values()[num - 2]+ " " + text;
    }

    public static void getOnes(int num)
    {
        text = ones.values()[num - 1]+ " " + text;
    }
}

Jetez un oeil àTradukisto . C'est une bibliothèque Java que j'ai écrite qui fait le travail.

Dans ce post, je viens de mettre à jour Yanick Rochon est code. Je l'ai rendu réalisable avec la version inférieure de java 1.6 et j'obtenais la sortie pour 1.00 = un centième. J'ai donc mis à jour le code. De nouveau je obtenir la sortie pour 1.00 = l'un et zéro centième.

Je ne sais pas ce que je dois faire. Ajoutez une nouvelle réponse ou modifiez ce message. Comme la réponse est très bien classée, j'ai donc fait un nouveau post avec la mise à jour du code. Je viens de changer ces deux les choses ont mentionné ci-dessus.

/**
 * This class will convert numeric values into an english representation
 * 
 * For units, see : http://www.jimloy.com/math/billion.htm
 * 
 * @author [email protected]
 */
public class NumberToWords {

    static public class ScaleUnit {
        private int exponent;
        private String[] names;

        private ScaleUnit(int exponent, String... names) {
            this.exponent = exponent;
            this.names = names;
        }

        public int getExponent() {
            return exponent;
        }

        public String getName(int index) {
            return names[index];
        }
    }

    /**
     * See http://www.wordiq.com/definition/Names_of_large_numbers
     */
    static private ScaleUnit[] SCALE_UNITS = new ScaleUnit[] {
            new ScaleUnit(63, "vigintillion", "decilliard"),
            new ScaleUnit(60, "novemdecillion", "decillion"),
            new ScaleUnit(57, "octodecillion", "nonilliard"),
            new ScaleUnit(54, "septendecillion", "nonillion"),
            new ScaleUnit(51, "sexdecillion", "octilliard"),
            new ScaleUnit(48, "quindecillion", "octillion"),
            new ScaleUnit(45, "quattuordecillion", "septilliard"),
            new ScaleUnit(42, "tredecillion", "septillion"),
            new ScaleUnit(39, "duodecillion", "sextilliard"),
            new ScaleUnit(36, "undecillion", "sextillion"),
            new ScaleUnit(33, "decillion", "quintilliard"),
            new ScaleUnit(30, "nonillion", "quintillion"),
            new ScaleUnit(27, "octillion", "quadrilliard"),
            new ScaleUnit(24, "septillion", "quadrillion"),
            new ScaleUnit(21, "sextillion", "trilliard"),
            new ScaleUnit(18, "quintillion", "trillion"),
            new ScaleUnit(15, "quadrillion", "billiard"),
            new ScaleUnit(12, "trillion", "billion"),
            new ScaleUnit(9, "billion", "milliard"),
            new ScaleUnit(6, "million", "million"),
            new ScaleUnit(3, "thousand", "thousand"),
            new ScaleUnit(2, "hundred", "hundred"),
            // new ScaleUnit(1, "ten", "ten"),
            // new ScaleUnit(0, "one", "one"),
            new ScaleUnit(-1, "tenth", "tenth"), new ScaleUnit(-2, "hundredth", "hundredth"),
            new ScaleUnit(-3, "thousandth", "thousandth"),
            new ScaleUnit(-4, "ten-thousandth", "ten-thousandth"),
            new ScaleUnit(-5, "hundred-thousandth", "hundred-thousandth"),
            new ScaleUnit(-6, "millionth", "millionth"),
            new ScaleUnit(-7, "ten-millionth", "ten-millionth"),
            new ScaleUnit(-8, "hundred-millionth", "hundred-millionth"),
            new ScaleUnit(-9, "billionth", "milliardth"),
            new ScaleUnit(-10, "ten-billionth", "ten-milliardth"),
            new ScaleUnit(-11, "hundred-billionth", "hundred-milliardth"),
            new ScaleUnit(-12, "trillionth", "billionth"),
            new ScaleUnit(-13, "ten-trillionth", "ten-billionth"),
            new ScaleUnit(-14, "hundred-trillionth", "hundred-billionth"),
            new ScaleUnit(-15, "quadrillionth", "billiardth"),
            new ScaleUnit(-16, "ten-quadrillionth", "ten-billiardth"),
            new ScaleUnit(-17, "hundred-quadrillionth", "hundred-billiardth"),
            new ScaleUnit(-18, "quintillionth", "trillionth"),
            new ScaleUnit(-19, "ten-quintillionth", "ten-trillionth"),
            new ScaleUnit(-20, "hundred-quintillionth", "hundred-trillionth"),
            new ScaleUnit(-21, "sextillionth", "trilliardth"),
            new ScaleUnit(-22, "ten-sextillionth", "ten-trilliardth"),
            new ScaleUnit(-23, "hundred-sextillionth", "hundred-trilliardth"),
            new ScaleUnit(-24, "septillionth", "quadrillionth"),
            new ScaleUnit(-25, "ten-septillionth", "ten-quadrillionth"),
            new ScaleUnit(-26, "hundred-septillionth", "hundred-quadrillionth"), };

    static public enum Scale {
        SHORT, LONG;

        public String getName(int exponent) {
            for (ScaleUnit unit : SCALE_UNITS) {
                if (unit.getExponent() == exponent) {
                    return unit.getName(this.ordinal());
                }
            }
            return "";
        }
    }

    /**
     * Change this scale to support American and modern British value (short scale) or Traditional
     * British value (long scale)
     */
    static public Scale SCALE = Scale.SHORT;

    static abstract public class AbstractProcessor {

        static protected final String SEPARATOR = " ";
        static protected final int NO_VALUE = -1;

        protected List<Integer> getDigits(long value) {
            ArrayList<Integer> digits = new ArrayList<Integer>();
            if (value == 0) {
                digits.add(0);
            } else {
                while (value > 0) {
                    digits.add(0, (int) value % 10);
                    value /= 10;
                }
            }
            return digits;
        }

        public String getName(long value) {
            return getName(Long.toString(value));
        }

        public String getName(double value) {
            return getName(Double.toString(value));
        }

        abstract public String getName(String value);
    }

    static public class UnitProcessor extends AbstractProcessor {

        static private final String[] TOKENS = new String[] { "one", "two", "three", "four",
                "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen",
                "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            int offset = NO_VALUE;
            int number;
            if (value.length() > 3) {
                number = Integer.valueOf(value.substring(value.length() - 3), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 100;
            if (number < 10) {
                offset = (number % 10) - 1;
                // number /= 10;
            } else if (number < 20) {
                offset = (number % 20) - 1;
                // number /= 100;
            }

            if (offset != NO_VALUE && offset < TOKENS.length) {
                buffer.append(TOKENS[offset]);
            }

            return buffer.toString();
        }

    }

    static public class TensProcessor extends AbstractProcessor {

        static private final String[] TOKENS = new String[] { "twenty", "thirty", "fourty",
                "fifty", "sixty", "seventy", "eighty", "ninety" };

        static private final String UNION_SEPARATOR = "-";

        private UnitProcessor unitProcessor = new UnitProcessor();

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();
            boolean tensFound = false;

            int number;
            if (value.length() > 3) {
                number = Integer.valueOf(value.substring(value.length() - 3), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 100; // keep only two digits
            if (number >= 20) {
                buffer.append(TOKENS[(number / 10) - 2]);
                number %= 10;
                tensFound = true;
            } else {
                number %= 20;
            }

            if (number != 0) {
                if (tensFound) {
                    buffer.append(UNION_SEPARATOR);
                }
                buffer.append(unitProcessor.getName(number));
            }

            return buffer.toString();
        }
    }

    static public class HundredProcessor extends AbstractProcessor {

        private int EXPONENT = 2;

        private UnitProcessor unitProcessor = new UnitProcessor();
        private TensProcessor tensProcessor = new TensProcessor();

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            int number;
            if ("".equals(value)) {
                number = 0;
            } else if (value.length() > 4) {
                number = Integer.valueOf(value.substring(value.length() - 4), 10);
            } else {
                number = Integer.valueOf(value, 10);
            }
            number %= 1000; // keep at least three digits

            if (number >= 100) {
                buffer.append(unitProcessor.getName(number / 100));
                buffer.append(SEPARATOR);
                buffer.append(SCALE.getName(EXPONENT));
            }

            String tensName = tensProcessor.getName(number % 100);

            if (!"".equals(tensName) && (number >= 100)) {
                buffer.append(SEPARATOR);
            }
            buffer.append(tensName);

            return buffer.toString();
        }
    }

    static public class CompositeBigProcessor extends AbstractProcessor {

        private HundredProcessor hundredProcessor = new HundredProcessor();
        private AbstractProcessor lowProcessor;
        private int exponent;

        public CompositeBigProcessor(int exponent) {
            if (exponent <= 3) {
                lowProcessor = hundredProcessor;
            } else {
                lowProcessor = new CompositeBigProcessor(exponent - 3);
            }
            this.exponent = exponent;
        }

        public String getToken() {
            return SCALE.getName(getPartDivider());
        }

        protected AbstractProcessor getHighProcessor() {
            return hundredProcessor;
        }

        protected AbstractProcessor getLowProcessor() {
            return lowProcessor;
        }

        public int getPartDivider() {
            return exponent;
        }

        @Override
        public String getName(String value) {
            StringBuilder buffer = new StringBuilder();

            String high, low;
            if (value.length() < getPartDivider()) {
                high = "";
                low = value;
            } else {
                int index = value.length() - getPartDivider();
                high = value.substring(0, index);
                low = value.substring(index);
            }

            String highName = getHighProcessor().getName(high);
            String lowName = getLowProcessor().getName(low);

            if (!"".equals(highName)) {
                buffer.append(highName);
                buffer.append(SEPARATOR);
                buffer.append(getToken());

                if (!"".equals(lowName)) {
                    buffer.append(SEPARATOR);
                }
            }

            if (!"".equals(lowName)) {
                buffer.append(lowName);
            }

            return buffer.toString();
        }
    }

    static public class DefaultProcessor extends AbstractProcessor {

        static private String MINUS = "minus";
        static private String UNION_AND = "and";

        static private String ZERO_TOKEN = "zero";

        private AbstractProcessor processor = new CompositeBigProcessor(63);

        @Override
        public String getName(String value) {
            boolean negative = false;
            if (value.startsWith("-")) {
                negative = true;
                value = value.substring(1);
            }

            int decimals = value.indexOf(".");
            String decimalValue = null;
            if (0 <= decimals) {
                decimalValue = value.substring(decimals + 1);
                value = value.substring(0, decimals);
            }

            String name = processor.getName(value);

            if ("".equals(name)) {
                name = ZERO_TOKEN;
            } else if (negative) {
                name = MINUS.concat(SEPARATOR).concat(name);
            }

            if (!(null == decimalValue || "".equals(decimalValue))) {

                String zeroDecimalValue = "";
                for (int i = 0; i < decimalValue.length(); i++) {
                    zeroDecimalValue = zeroDecimalValue + "0";
                }
                if (decimalValue.equals(zeroDecimalValue)) {
                    name = name.concat(SEPARATOR).concat(UNION_AND).concat(SEPARATOR).concat(
                            "zero").concat(SEPARATOR).concat(
                            SCALE.getName(-decimalValue.length()));
                } else {
                    name = name.concat(SEPARATOR).concat(UNION_AND).concat(SEPARATOR).concat(
                            processor.getName(decimalValue)).concat(SEPARATOR).concat(
                            SCALE.getName(-decimalValue.length()));
                }

            }

            return name;
        }

    }

    static public AbstractProcessor processor;

    public static void main(String... args) {

        processor = new DefaultProcessor();

        long[] values = new long[] { 0, 4, 10, 12, 100, 108, 299, 1000, 1003, 2040, 45213, 100000,
                100005, 100010, 202020, 202022, 999999, 1000000, 1000001, 10000000, 10000007,
                99999999, Long.MAX_VALUE, Long.MIN_VALUE };

        String[] strValues = new String[] { "0", "1.30", "0001.00", "3.141592" };

        for (long val : values) {
            System.out.println(val + " = " + processor.getName(val));
        }

        for (String strVal : strValues) {
            System.out.println(strVal + " = " + processor.getName(strVal));
        }

        // generate a very big number...
        StringBuilder bigNumber = new StringBuilder();
        for (int d = 0; d < 66; d++) {
            bigNumber.append((char) ((Math.random() * 10) + '0'));
        }
        bigNumber.append(".");
        for (int d = 0; d < 26; d++) {
            bigNumber.append((char) ((Math.random() * 10) + '0'));
        }
        System.out.println(bigNumber.toString() + " = " + processor.getName(bigNumber.toString()));
    }
}

La sortie est

0 = zero
4 = four
10 = ten
12 = twelve
100 = one hundred
108 = one hundred eight
299 = two hundred ninety-nine
1000 = one thousand
1003 = one thousand three
2040 = two thousand fourty
45213 = fourty-five thousand two hundred thirteen
100000 = one hundred thousand
100005 = one hundred thousand five
100010 = one hundred thousand ten
202020 = two hundred two thousand twenty
202022 = two hundred two thousand twenty-two
999999 = nine hundred ninety-nine thousand nine hundred ninety-nine
1000000 = one million
1000001 = one million one
10000000 = ten million
10000007 = ten million seven
99999999 = ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-nine
9223372036854775807 = nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred seven
-9223372036854775808 = minus nine quintillion two hundred twenty-three quadrillion three hundred seventy-two trillion thirty-six billion eight hundred fifty-four million seven hundred seventy-five thousand eight hundred eight
0.0 = zero and zero tenth
1.30 = one and thirty hundredth
0001.00 = one and zero hundredth
3.141592 = three and one hundred fourty-one thousand five hundred ninety-two millionth
354064188376576616844741830273568537829518115677552666352927559274.76892492652888527014418647 = three hundred fifty-four vigintillion sixty-four novemdecillion one hundred eighty-eight octodecillion three hundred seventy-six septendecillion five hundred seventy-six sexdecillion six hundred sixteen quindecillion eight hundred fourty-four quattuordecillion seven hundred fourty-one tredecillion eight hundred thirty duodecillion two hundred seventy-three undecillion five hundred sixty-eight decillion five hundred thirty-seven nonillion eight hundred twenty-nine octillion five hundred eighteen septillion one hundred fifteen sextillion six hundred seventy-seven quintillion five hundred fifty-two quadrillion six hundred sixty-six trillion three hundred fifty-two billion nine hundred twenty-seven million five hundred fifty-nine thousand two hundred seventy-four and seventy-six septillion eight hundred ninety-two sextillion four hundred ninety-two quintillion six hundred fifty-two quadrillion eight hundred eighty-eight trillion five hundred twenty-seven billion fourteen million four hundred eighteen thousand six hundred fourty-seven hundred-septillionth

package it.tommasoresti.facebook;

class NumbersToWords {

    private static final String ZERO = "zero";
    private static String[] oneToNine = {
            "one", "two", "three", "four", "five", "six", "seven", "height", "nine"
    };

    private static String[] tenToNinteen = {
            "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
    };

    private static String[] dozens = {
            "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
    };

    public static String solution(int number) {
        if(number == 0)
            return ZERO;

        return generate(number).trim();
    }

    public static String generate(int number) {
        if(number >= 1000000000) {
            return generate(number / 1000000000) + " billion " + generate(number % 1000000000);
        }
        else if(number >= 1000000) {
            return generate(number / 1000000) + " million " + generate(number % 1000000);
        }
        else if(number >= 1000) {
            return generate(number / 1000) + " thousand " + generate(number % 1000);
        }
        else if(number >= 100) {
            return generate(number / 100) + " hundred " + generate(number % 100);
        }

        return generate1To99(number);
    }

    private static String generate1To99(int number) {
        if (number == 0)
            return "";

        if (number <= 9)
            return oneToNine[number - 1];
        else if (number <= 19)
            return tenToNinteen[number % 10];
        else {
            return dozens[number / 10 - 1] + " " + generate1To99(number % 10);
        }
    }
}

Test

@Test
public void given_a_complex_number() throws Exception {
    assertThat(solution(1234567890),
        is("one billion two hundred thirty four million five hundred sixty seven thousand height hundred ninety"));
}

Je pense que cela peut vous aider...le programme est très simple et fonctionne bien

import java.util.*;

public class NumberToWord

{
    public void pw(int n, String ch)
    {
        String one[] = {

        " ", " one", " two", " three", " four", " five", " six", " seven",
                " eight", " Nine", " ten", " eleven", " twelve", " thirteen",
                " fourteen", "fifteen", " sixteen", " seventeen", " eighteen",
                " nineteen" };
        String ten[] = { " ", " ", " twenty", " thirty", " forty", " fifty",
                " sixty", "seventy", " eighty", " ninety" };
        if (n > 19) {
            System.out.print(ten[n / 10] + " " + one[n % 10]);
        } else {
            System.out.print(one[n]);
        }
        if (n > 0)
            System.out.print(ch);

    }
    public static void main(String[] args)

    {
        int n = 0;
        Scanner s = new Scanner(System.in);
        System.out.print("Enter an integer number: ");
        n = s.nextInt();
        if (n <= 0)
            System.out.print("Enter numbers greater than 0");
        else
        {
            NumberToWord a = new NumberToWord();
            System.out.print("After conversion number in words is :");
            a.pw((n / 1000000000), " Hundred");
            a.pw((n / 10000000) % 100, " crore");
            a.pw(((n / 100000) % 100), " lakh");
            a.pw(((n / 1000) % 100), " thousand");
            a.pw(((n / 100) % 10), " hundred");
            a.pw((n % 100), " ");
        }
    }
}

Vous pouvez utiliser RuleBasedNumberFormat. par exemple, le résultat vous donnera Ninety

ULocale locale = new ULocale(Locale.US);  //us english
Double d = Double.parseDouble(90);
NumberFormat formatter = new RuleBasedNumberFormat(locale, RuleBasedNumberFormat.SPELLOUT);
String result = formatter.format(d);

Il prend en charge un large éventail de langues.

J'ai écrit une version propre pour les entiers 32 bits et l'anglais américain:

Http://www.source-code.biz/snippets/java/13.htm

/* this program will display number in words
for eg. if you enter 101,it will show "ONE HUNDRED AND ONE"*/

import java.util.*;

public class NumToWords {
  String string;
  String st1[] = { "", "one", "two", "three", "four", "five", "six", "seven",
                   "eight", "nine", };
  String st2[] = { "hundred", "thousand", "lakh", "crore" };
  String st3[] = { "ten", "eleven", "twelve", "thirteen", "fourteen",
                   "fifteen", "sixteen", "seventeen", "eighteen", "ninteen", };
  String st4[] = { "twenty", "thirty", "fourty", "fifty", "sixty", "seventy",
                   "eighty", "ninety" };

  public String convert(int number) {
    int n = 1;
    int word;
    string = "";
    while (number != 0) {
      switch (n) {
        case 1:
          word = number % 100;
          pass(word);
          if (number > 100 && number % 100 != 0) {
            show("and ");
            //System.out.print("ankit");
          }
          number /= 100;
          break;
        case 2:
          word = number % 10;
          if (word != 0) {
            show(" ");
            show(st2[0]);
            show(" ");
            pass(word);
          }
          number /= 10;
          break;
        case 3:
          word = number % 100;
          if (word != 0) {
            show(" ");
            show(st2[1]);
            show(" ");
            pass(word);
          }
          number /= 100;
          break;
        case 4:
          word = number % 100;
          if (word != 0) {
            show(" ");
            show(st2[2]);
            show(" ");
            pass(word);
          }
          number /= 100;
          break;
        case 5:
          word = number % 100;
          if (word != 0) {
            show(" ");
            show(st2[3]);
            show(" ");
            pass(word);
          }
          number /= 100;
          break;
        }
        n++;
      }
      return string;
    }

  public void pass(int number) {
    int word, q;
    if (number < 10) {
      show(st1[number]);
    }
    if (number > 9 && number < 20) {
      show(st3[number - 10]);
    }
    if (number > 19) {
      word = number % 10;
      if (word == 0) {
        q = number / 10;
        show(st4[q - 2]);
      } else {
        q = number / 10;
        show(st1[word]);
        show(" ");
        show(st4[q - 2]);
      }
    }
  }

  public void show(String s) {
    String st;
    st = string;
    string = s;
    string += st;
  }

  public static void main(String[] args) {
    NumToWords w = new NumToWords();
    Scanner input = new Scanner(System.in);
    System.out.print("Enter Number: ");
    int num = input.nextInt();
    String inwords = w.convert(num);
    System.out.println(inwords);
  }
}

Vient de télécharger une version extensible! NumberReader @ SourceForge

C'est une autre façon...(avec une portée limitée)

public static String numToWord(Integer i) {

 final  String[] units = { "Zero", "One", "Two", "Three",
        "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven",
        "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
        "Seventeen", "Eighteen", "Nineteen" };
 final  String[] tens = { "", "", "Twenty", "Thirty", "Forty",
        "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
    if (i < 20)
        return units[i];
    if (i < 100)
        return tens[i / 10] + ((i % 10 > 0) ? " " + numToWord(i % 10) : "");
    if (i < 1000)
        return units[i / 100] + " Hundred"
                + ((i % 100 > 0) ? " and " + numToWord(i % 100) : "");
    if (i < 1000000)
        return numToWord(i / 1000) + " Thousand "
                + ((i % 1000 > 0) ? " " + numToWord(i % 1000) : "");
    return numToWord(i / 1000000) + " Million "
            + ((i % 1000000 > 0) ? " " + numToWord(i % 1000000) : "");
}

import java.util.*;

public class NumberToWord {
    public void numberToword(int n, String ch) {
        String one[] = {" ", " one", " two", " three", " four", " five", " six", " seven", " eight", " Nine", " ten", " eleven", " twelve", " thirteen", " fourteen", "fifteen", " sixteen", " seventeen", " eighteen", " nineteen"
        };
        String ten[] = {" ", " ", " twenty", " thirty", " forty", " fifty", " sixty", "seventy", " eighty", " ninety"};
        if (n > 19) {
            System.out.print(ten[n / 10] + " " + one[n % 10]);
        } else {
            System.out.print(one[n]);
        }
        if (n > 0) {
            System.out.print(ch);
        }
    }
    public static void main(String[] args) {
        int n = 0;
        Scanner s = new Scanner(System.in);
        System.out.print("Enter an integer number: ");
        n = s.nextInt();
        if (n <= 0) {
            System.out.print("Enter numbers greater than 0");
        } else {
            NumberToWord a = new NumberToWord();
            System.out.print("After conversion number in words is :");
            a.numberToword((n / 1000000000), " Hundred");
            a.numberToword((n / 10000000) % 100, " crore");
            a.numberToword(((n / 100000) % 100), " lakh");
            a.numberToword(((n / 1000) % 100), " thousand");
            a.numberToword(((n / 100) % 10), " hundred");
            a.numberToword((n % 100), " ");
        }
    }
}

Cela pourrait aider

public String numberToWords(long number) {
    if (number == 0) {
        return "zero";
    }
    if (number < 0) {
        return "minus " + numberToWords(Math.abs(number));
    }
    String words = "";
    if ((number / 10000000) > 0) {
        words += numberToWords(number / 10000000) + " Crore ";
        number %= 10000000;
    }
    if ((number / 100000) > 0) {
        words += numberToWords(number / 100000) + " Lakh ";
        number %= 100000;
    }
    if ((number / 1000) > 0) {
        words += numberToWords(number / 1000) + " Thousand ";
        number %= 1000;
    }
    if ((number / 100) > 0) {
        words += numberToWords(number / 100) + " Hundred ";
        number %= 100;
    }
    if (number > 0) {
        if (!words.equals("")) {
            words += "and ";
        }
        if (number < 20) {
            words += number;
        } else {
            words += (number);
            if ((number % 10) > 0) {
                words += "-" + (number % 10);
            }
        }
    }
    return words;
}

Vous n'en avez probablement plus besoin, mais j'ai récemment écrit une classe java pour le faire. Apparemment, Yanick Rochon a fait quelque chose de similaire. Il convertira les nombres jusqu'à 999 Novemdecillion (999*10^60). Il pourrait faire plus si je savais ce qui est venu après Novemdecillion, mais je serais prêt à parier que ce n'est pas nécessaire. Il suffit d'alimenter le nombre sous forme de chaîne en cents. La sortie est également grammaticalement correcte.

Voici un lien vers le dépôt Bitbucket

La même réponse acceptée (Jigar Joshi), mais maintenant en espagnol. N'hésitez pas à changer si vous trouvez une erreur. Plus facile que le français,mais basé sur ça....

Espagnol:

import java.text.*;

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

  private static final String[] unitNames1 = {
    "",
    "un",
    "dos",
    "tres",
    "cuatro",
    "cinco",
    "seis",
    "siete",
    "ocho",
    "nueve",
    "diez",
    "once",
    "doce",
    "trece",
    "catorce",
    "quince",
    "dieciseis",
    "diecisiete",
    "dieciocho",
    "diecinueve",
    "veinte",
    "veintiun",
    "veintidos",
    "veintitres",
    "veinticuatro",
    "veinticinco",
    "veintiseis",
    "veintisiete",
    "veintiocho",
    "veintinueve",
  };

  private static final String[] unitNames2 = {
    "",
    "",
    "dosc",
    "tresc",
    "cuatroc",
    "quin",
    "seisc",
    "setec",
    "ochoc",
    "novec",
    "diez"
  };

  private SpanishNumberToWords() {}

  private static String convertZeroToHundred(int number) {

    int theTens = number / 10;
    int theUnit = number % 10;
    String result = "";

    // separator
    String theSeparator = "";
    if (theTens > 1) {
        theSeparator = " y ";
    }
    // particular cases
    switch (theUnit) {
    case 0:
        theSeparator = "";
      break;
    default:
    }

    // tens in letters
    switch (theTens) {
    case 0:
        result = unitNames1[theUnit];
      break;
    case 1: case 2:
        result =  unitNames1[theTens*10+theUnit];
        break;
    default :
        result = tensNames[theTens]
                              + theSeparator + unitNames1[theUnit];
    }
    return result;
  }

  private static String convertLessThanOneThousand(int number) {

    int theHundreds = number / 100;
    int leReste = number % 100;
    String sReste = convertZeroToHundred(leReste);

    String result;
    switch (theHundreds) {
    case 0:
        result = sReste;
      break;
    case 1 :
      if (leReste > 0) {
          result = "ciento " + sReste;
      }
      else {
          result = "cien";
      }
      break;
    default :
      if (leReste > 0) {
          result = unitNames2[theHundreds] + "ientos " + sReste;
      }
      else {
          result = unitNames2[theHundreds] + "ientos";
      }
    }
    return result;
  }

  public static String convert(long number) {
    // 0 à 999 999 999 999
    if (number == 0) { return "cero"; }

    String snumber = Long.toString(number);

    // pad des "0"
    String mask = "000000000000";
    DecimalFormat df = new DecimalFormat(mask);
    snumber = df.format(number);

    // XXXnnnnnnnnn
    int theMilliards = Integer.parseInt(snumber.substring(0,3));
    // nnnXXXnnnnnn
    int theMillions  = Integer.parseInt(snumber.substring(3,6));
    // nnnnnnXXXnnn
    int theCentMiles = Integer.parseInt(snumber.substring(6,9));
    // nnnnnnnnnXXX
    int lesMille = Integer.parseInt(snumber.substring(9,12));

    String tradMilliards;
    switch (theMilliards) {
    case 0:
      tradMilliards = "";
      break;
    case 1 :
      tradMilliards = convertLessThanOneThousand(theMilliards)
         + " mil millones ";
      break;
    default :
      tradMilliards = convertLessThanOneThousand(theMilliards)
         + " mil millones ";
    }
    String resultat =  tradMilliards;

    String tradMillions;
    switch (theMillions) {
    case 0:
      tradMillions = "";
      break;
    case 1 :
      tradMillions = convertLessThanOneThousand(theMillions)
         + " millon ";
      break;
    default :
      tradMillions = convertLessThanOneThousand(theMillions)
         + " millones ";
    }
    resultat =  resultat + tradMillions;

    String tradCentMille;
    switch (theCentMiles) {
    case 0:
      tradCentMille = "";
      break;
    case 1 :
      tradCentMille = "mil ";
      break;
    default :
      tradCentMille = convertLessThanOneThousand(theCentMiles)
         + " mil ";
    }
    resultat =  resultat + tradCentMille;

    String tradMille;
    tradMille = convertLessThanOneThousand(lesMille);
    resultat =  resultat + tradMille;

    return resultat;
  }

  public static void main(String[] args) {
    System.out.println("*** " + SpanishNumberToWords.convert(0));
    System.out.println("*** " + SpanishNumberToWords.convert(1));
    System.out.println("*** " + SpanishNumberToWords.convert(2));
    System.out.println("*** " + SpanishNumberToWords.convert(3));
    System.out.println("*** " + SpanishNumberToWords.convert(4));
    System.out.println("*** " + SpanishNumberToWords.convert(5));
    System.out.println("*** " + SpanishNumberToWords.convert(7));
    System.out.println("*** " + SpanishNumberToWords.convert(12));
    System.out.println("*** " + SpanishNumberToWords.convert(16));
    System.out.println("*** " + SpanishNumberToWords.convert(19));
    System.out.println("*** " + SpanishNumberToWords.convert(21));
    System.out.println("*** " + SpanishNumberToWords.convert(24));
    System.out.println("*** " + SpanishNumberToWords.convert(28));
    System.out.println("*** " + SpanishNumberToWords.convert(29));
    System.out.println("*** " + SpanishNumberToWords.convert(30));
    System.out.println("*** " + SpanishNumberToWords.convert(31));
    System.out.println("*** " + SpanishNumberToWords.convert(42));
    System.out.println("*** " + SpanishNumberToWords.convert(71));
    System.out.println("*** " + SpanishNumberToWords.convert(72));
    System.out.println("*** " + SpanishNumberToWords.convert(80));
    System.out.println("*** " + SpanishNumberToWords.convert(81));
    System.out.println("*** " + SpanishNumberToWords.convert(89));
    System.out.println("*** " + SpanishNumberToWords.convert(90));
    System.out.println("*** " + SpanishNumberToWords.convert(91));
    System.out.println("*** " + SpanishNumberToWords.convert(97));
    System.out.println("*** " + SpanishNumberToWords.convert(100));
    System.out.println("*** " + SpanishNumberToWords.convert(101));
    System.out.println("*** " + SpanishNumberToWords.convert(110));
    System.out.println("*** " + SpanishNumberToWords.convert(120));
    System.out.println("*** " + SpanishNumberToWords.convert(200));
    System.out.println("*** " + SpanishNumberToWords.convert(201));
    System.out.println("*** " + SpanishNumberToWords.convert(232));
    System.out.println("*** " + SpanishNumberToWords.convert(999));
    System.out.println("*** " + SpanishNumberToWords.convert(521));
    System.out.println("*** " + SpanishNumberToWords.convert(912));
    System.out.println("*** " + SpanishNumberToWords.convert(999));
    System.out.println("*** " + SpanishNumberToWords.convert(1000));
    System.out.println("*** " + SpanishNumberToWords.convert(1001));
    System.out.println("*** " + SpanishNumberToWords.convert(10000));
    System.out.println("*** " + SpanishNumberToWords.convert(10001));
    System.out.println("*** " + SpanishNumberToWords.convert(100000));
    System.out.println("*** " + SpanishNumberToWords.convert(267578));
    System.out.println("*** " + SpanishNumberToWords.convert(3000000000L));
    System.out.println("*** " + SpanishNumberToWords.convert(2147483647));
    /*
     *** OUTPUT
        *** cero
        *** un
        *** dos
        *** tres
        *** cuatro
        *** cinco
        *** siete
        *** doce
        *** dieciseis
        *** diecinueve
        *** veintiun
        *** veinticuatro
        *** veintiocho
        *** veintinueve
        *** treinta
        *** treinta y un
        *** cuarenta y dos
        *** setenta y un
        *** setenta y dos
        *** ochenta
        *** ochenta y un
        *** ochenta y nueve
        *** noventa
        *** noventa y un
        *** noventa y siete
        *** cien
        *** ciento un
        *** ciento diez
        *** ciento veinte
        *** doscientos
        *** doscientos un
        *** doscientos treinta y dos
        *** novecientos noventa y nueve
        *** quinientos veintiun
        *** novecientos doce
        *** novecientos noventa y nueve
        *** mil 
        *** mil un
        *** diez mil 
        *** diez mil un
        *** cien mil 
        *** doscientos sesenta y siete mil quinientos setenta y ocho
        *** tres mil millones 
        *** dos mil millones ciento cuarenta y siete millones cuatrocientos ochenta y tres mil seiscientos cuarenta y siete
     */
  }

class NumberToWord {
    private static Map<Integer, String> numbers = new HashMap<Integer, String>();
    private static Set<Integer> numberSet = new TreeSet<Integer>(new Comparator<Integer>() {
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });

    static {
        init();
        numberSet.addAll(numbers.keySet());
    }

    public static void main(String[] args) {
        System.out.println(getNumberInWord(1898765));
    }

    /*
     * convert positive numbers in word format number > 0 only
     */
    static String getNumberInWord(int number) {
        StringBuilder word = new StringBuilder();
        for (Integer n : numberSet) {
            if (number > 0 && number >= n) {
                int div = number / n;
                String strNum = numbers.get(div);
                if (strNum == null) {
                    word.append(getNumberInWord(div));
                }
                // for less than 100, we don't need to say 1
                if (strNum != null && (div > 1 || n > 100))
                    word.append(strNum + " ");

                word.append(numbers.get(n) + " ");
                number = number % n;
            }
        }
        return word.toString();
    }

    static void init() {
        numbers.put(0, "Zero");
        numbers.put(1, "One");
        numbers.put(2, "Two");
        numbers.put(3, "Three");
        numbers.put(4, "Four");
        numbers.put(5, "Five");
        numbers.put(6, "Six");
        numbers.put(7, "Seven");
        numbers.put(8, "Eight");
        numbers.put(9, "Nine");
        numbers.put(10, "Ten");
        numbers.put(11, "Eleven");
        numbers.put(12, "Twelve");
        numbers.put(13, "Thirteen");
        numbers.put(14, "Fourteen");
        numbers.put(15, "Fifteen");
        numbers.put(16, "Sixteen");
        numbers.put(17, "Seventeen");
        numbers.put(18, "Eighteeen");
        numbers.put(19, "Nineteen");
        numbers.put(20, "Twenty");
        numbers.put(30, "Thirty");
        numbers.put(40, "Forty");
        numbers.put(50, "Fifty");
        numbers.put(60, "Sixty");
        numbers.put(70, "Seventy");
        numbers.put(80, "Eighty");
        numbers.put(90, "Ninty");
        numbers.put(100, "Hundred");
        numbers.put(1000, "Thousand");
        numbers.put(1000000, "Million");
        numbers.put(100000000, "Billion");
    }

}

J'ai développé un composant Java pour convertir un nombre donné en mots. Tout ce que vous avez à faire est de copier toute la classe à partir de Programme Java pour convertir des nombres en mots et collez - le dans votre projet.

Il suffit de l'invoquer comme ci-dessous

Words w = Words.getInstance(1234567);
System.out.println(w.getNumberInWords());

Mon programme prend en charge jusqu'à 10 millions. Si vous voulez, vous pouvez toujours étendre cela. Juste en dessous de l'exemple de sortie

2345223 = Twenty Three Lakh Fourty Five Thousand Two Hundred Twenty Three
9999999 = Ninety Nine Lakh Ninety Nine Thousand Nine Hundred Ninety Nine
199 = One Hundred Ninety Nine
10 = Ten

Merci

Santhosh

/* This program will print words for a number between 0 to 99999*/

    public class NumberInWords5Digits {

        static int testcase1 = 93284;

        public static void main(String args[]){
            NumberInWords5Digits testInstance = new NumberInWords5Digits();
            String result = testInstance.inWords(testcase1);
            System.out.println("Result : "+result);
        }

        //write your code here
        public String inWords(int num){
            int digit = 0;
            String word = "";
            int temp = num;
            while(temp>0)
            {
                if(temp%10 >= 0)
                    digit++;
                temp = temp/10;
            }

            if(num == 0)
                return "zero";

            System.out.println(num);
            if(digit == 1)
                word = inTens(num, digit);
            else if(digit == 2)
                word = inTens(num, digit);
            else if(digit == 3)
                word = inHundreds(num, digit);
            else if(digit == 4)
                word = inThousands(num, digit);
            else if(digit == 5)
                word = inThousands(num, digit);
            return word;
        }

        public String inTens(int num, int digit){
            int tens = 0;
            int units = 0;
            if(digit == 2)      
            {
                tens = num/10;
                units = num%10;
            }
            String unit = "";
            String ten = "";
            String word = "";

            if(num == 10)
            {word = "ten"; return word;}

            if(num == 11)
            {word = "eleven"; return word;}
            if(num == 12)
            {word = "twelve"; return word;}
            if(num == 13)
            {word = "thirteen"; return word;}
            if(num == 14)
            {word = "fourteen"; return word;}
            if(num == 15)
            {word = "fifteen"; return word;}
            if(num == 16)
            {word = "sixteen"; return word;}
            if(num == 17)
            {word = "seventeen"; return word;}
            if(num == 18)
            {word = "eighteen"; return word;}
            if(num == 19)
            {word = "nineteen"; return word;}

            if(units == 1 || num == 1)
                unit = "one";
            else if(units == 2 || num == 2)
                unit = "two";
            else if(units == 3 || num == 3)
                unit = "three";
            else if(units == 4 || num == 4)
                unit = "four";
            else if(units == 5 || num == 5)
                unit = "five";
            else if(units == 6 || num == 6)
                unit = "six";
            else if(units == 7 || num == 7)
                unit = "seven";
            else if(units == 8 || num == 8)
                unit = "eight";
            else if(units == 9 || num == 9)
                unit = "nine";

            if(tens == 2)
                ten = "twenty";
            else if(tens == 3)
                ten = "thirty";
            else if(tens == 4)
                ten = "forty";
            else if(tens == 5)
                ten = "fifty";
            else if(tens == 6)
                ten = "sixty";
            else if(tens == 7)
                ten = "seventy";
            else if(tens == 8)
                ten = "eighty";
            else if(tens == 9)
                ten = "ninety";

            if(digit == 1)
                word = unit;
            else if(digit == 2)
                word = ten + " " + unit;
            return word;
        }

        //inHundreds(525, 3)
        public String inHundreds(int num, int digit){

            int hundreds = num/100; // =5
            int tensAndUnits = num%100; // =25
            String hundred = "";
            String tenAndUnit = "";
            String word = "";

            tenAndUnit = inTens(tensAndUnits, 2);

            if(hundreds == 1)
                hundred = "one hundred";
            else if(hundreds == 2)
                hundred = "two hundred";
            else if(hundreds == 3)
                hundred = "three hundred";
            else if(hundreds == 4)
                hundred = "four hundred";
            else if(hundreds == 5)
                hundred = "five hundred";
            else if(hundreds == 6)
                hundred = "six hundred";
            else if(hundreds == 7)
                hundred = "seven hundred";
            else if(hundreds == 8)
                hundred = "eight hundred";
            else if(hundreds == 9)
                hundred = "nine hundred";

            word = hundred + " " + tenAndUnit;
            return word;
        }

        public String inThousands(int num, int digit){

            int thousands = 0;      
            int hundredsAndOthers = num%1000;
            String thousand = "";
            String hundredAndOther = "";
            String word = "";
            if(digit == 5)
            {
                thousands = num/1000;
                thousand = inTens(thousands, 2);            
            }
            else if(digit == 4)
            {
                thousands = num/1000;
                thousand = inTens(thousands, 1);
            }

            if(hundredsAndOthers/100 == 0) // in case of "023"
                hundredAndOther = inTens(hundredsAndOthers, 2);
            else
                hundredAndOther = inHundreds(hundredsAndOthers, 3);

            word = thousand + " thousand " + hundredAndOther;

            return word;
        }
    }

import java.lang.*;
import java.io.*;
public class rupee
{
public static void main(String[] args)throws  IOException
{

 int len=0,revnum=0,i,dup=0,j=0,k=0;
 int gvalue;
  String[] ones={"one","Two","Three","Four","Five","Six","Seven","Eight","Nine","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen",""};
    String[] twos={"Ten","Twenty","Thirty","Fourty","fifty","Sixty","Seventy","eighty","Ninety",""};
System.out.println("\n Enter value");
InputStreamReader b=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(b);
gvalue=Integer.parseInt(br.readLine());
if(gvalue==10)

System.out.println("Ten");

else if(gvalue==100)

System.out.println("Hundred");

else if(gvalue==1000)
System.out.println("Thousand");

dup=gvalue;
for(i=0;dup>0;i++)
{
revnum=revnum*10+dup%10;
len++;
dup=dup/10;
}
while(j<len)
{
if(gvalue<10)
{
System.out.println(ones[gvalue-1]);
}
else if(gvalue>10&&gvalue<=19)
{
System.out.println(ones[gvalue-2]);
break;
}
else if(gvalue>19&&gvalue<100)
{
k=gvalue/10;
gvalue=gvalue%10;
System.out.println(twos[k-1]);
}
else if(gvalue>100&&gvalue<1000)
{
k=gvalue/100;
gvalue=gvalue%100;
System.out.println(ones[k-1] +"Hundred");
}
else if(gvalue>=1000&&gvalue<9999)
{
k=gvalue/1000;
gvalue=gvalue%1000;
System.out.println(ones[k-1]+"Thousand");
    }
else if(gvalue>=11000&&gvalue<=19000)
{
    k=gvalue/1000;
    gvalue=gvalue%1000;
    System.out.println(twos[k-2]+"Thousand");
}       
else if(gvalue>=12000&&gvalue<100000)
{
k=gvalue/10000;
    gvalue=gvalue%10000;
System.out.println(ones[gvalue-1]);
}
else
{
System.out.println("");
    }
j++;
}
}
}

Je l'ai implémenté comme ceci

package com.stack.overflow.number.in.english;

import java.util.ResourceBundle;

public class ActualImplementation {

    public static ResourceBundle readPropertyFile = ResourceBundle
            .getBundle("NumberEnglishRepresentation");

    public static void main(String[] args) {
        System.out.println(ActualImplementation.main(-2));
    }

    public static String main(Integer number) {
        int power;
        // Calculate Number of digits

        Integer numberOfDigits = number > 0 ? (int) Math.log10((double) number) + 1
                : 1;
        String output = "";
        // If number is negative convert it to positive an append minus to
        // output
        if (Integer.signum(number) == -1) {
            output = "minus ";
            number = number < 0 ? number * -1 : number;
        }
        String stringVal = String.valueOf(number);

        if (number <= 20 || number == 30 || number == 40 || number == 50
                || number == 60 || number == 70 || number == 80 || number == 90
                || number == 100 || number == 1000)
            output += readPropertyFile.getString(stringVal);

        else {
            int i;
            for (i = 0; i < numberOfDigits; i++) {

                if (number != 0) {

                    numberOfDigits = number > 0 ? (int) Math
                            .log10((double) number) + 1 : 1;

                    power = (int) Math.pow(10, numberOfDigits - 1);
                    // If number is like 10,001 then print ten first and then
                    // remaining value
                    if (numberOfDigits >= 5 && numberOfDigits % 2 == 1) {
                        power = (int) Math.pow(10, numberOfDigits - 2);
                    }

                    if (readPropertyFile.containsKey(String.valueOf(number)))
                        output += readPropertyFile.getString(String
                                .valueOf(number));
                    else {
                        // As the digits at units and tens place are read
                        // differently
                        if (numberOfDigits > 2) {

                            output += readPropertyFile.getString(String
                                    .valueOf(number / power))
                                    + readPropertyFile.getString(String
                                            .valueOf(power));
                        } else {
                            output += readPropertyFile.getString(String
                                    .valueOf(number - number % power));

                        }
                    }
                    number = (int) (number % power);

                }
            }
        }

        return output;
    }
}

Et le fichier de ressources est :

0=zero
1=one
2=two
3=three
4=four
5=five
6=six
7=seven
8=eight
9=nine
10=ten 


11=eleven
12=twelve
13=thirteen
14=fourteen
15fifteen
16=sixteen
17=seventeen
18=eighteen
19=nineteen
20=twenty

30=thirty
40=fourty
50=fifty
60=sixty
70=seventy
80=eighty
90=ninety

100=hundred
1000=thousand
100000=Lakh

Celui-ci est implémenté jusqu'à 10 lakhs seulement

public class NumberConverter {

    private String[] singleDigit = {"", " one", " two", " three",
    " four", " five"," six", " seven", " eight", " nine"};

    private String[] tens = {" ten", " eleven", " twelve", " thirteen",
            " fourteen", " fifteen"," sixteen", " seventeen", " eighteen", " nineteen"};

    private String[] twoDigits = {"", "", " twenty", " thirty",
            " forty", " fifty"," sixty", " seventy", " eighty", " ninety"};

    public String convertToWords(String input) {
        long number = Long.parseLong(input);
        int size = input.length();
        if (size <= 3) {
            int num = (int) number;
            return handle3Digits(num);
        } else if (size > 3 && size <= 6) {
            int thousand = (int)(number/1000);
            int hundred = (int) (number % 1000);
            String thousands = handle3Digits(thousand);

            String hundreds = handle3Digits(hundred);
            String word = "";

            if (!thousands.isEmpty()) {
                word = thousands +" thousand";
            }
            word += hundreds;
            return word;
        } else if (size > 6 && size <= 9) {
            int million = (int) (number/ 1000000);
            number = number % 1000000;
            int thousand = (int)(number/1000);
            int hundred = (int) (number % 1000);

            String millions = handle3Digits(million);
            String thousands = handle3Digits(thousand);
            String hundreds = handle3Digits(hundred);

            String word = "";

            if (!millions.isEmpty()) {
                word = millions +" million";
            }
            if (!thousands.isEmpty()) {
                word += thousands +" thousand";
            }
            word += hundreds;
            return word;
        }

        return "Not implemented yet.";
    }


    private String handle3Digits(int number) {
        if (number <= 0)
            return "";

        String word = "";
        if (number/100 > 0) {
            int dividend = number/100;
            word = singleDigit[dividend] + " hundred";
            number = number % 100;
        }
        if (number/10 > 1) {
            int dividend = number/10;
            number = number % 10;
            word += twoDigits[dividend];
        } else if (number/10 == 1) {
            number = number % 10;
            word += tens[number];
            return word;
        } else {
            number = number % 10;
        }
        if (number > 0) {
            word += singleDigit[number];
        }

        return word;
    }
}

    import java.util.Scanner;

public class StringToNum {
public static void main(String args[])
  {
    Scanner sc=new Scanner(System.in);
    System.out.println("Enter the no: ");
    int  no=sc.nextInt();
    int arrNum[]=new int[10];
    int i=0;
    while(no!=0)
    {
      arrNum[i]=no%10;
      no=no/10;
      i++;
    }
    int len=i;
    int arrNum1[]=new int[len];
    int j=0;
    for(int k=len-1;k>=0;k--)
    {
        arrNum1[j]=arrNum[k];
        j++;
    }
    StringToNum stn=new StringToNum();
    String output="";
    switch(len)
    {
      case 1:
      {
         output+=stn.strNum1(arrNum1[len-1]);
         System.out.println("output="+output);
         break;
      }
      case 2:
      {
        int no1=arrNum1[len-2]*10+arrNum1[len-1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        // output=output+" "+stn.strNum1(arrNum1[len-1]);
         System.out.println("output="+output);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
         System.out.println("output="+output);
        }
         break;
      }
      case 3:
      {
        output=stn.strNum1(arrNum1[len-3])+" hundred ";
        int no1=arrNum1[len-2]*10+arrNum1[len-1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
        }
        System.out.println("output="+output);  
        break;
      }
      case 4:
      {
        output=stn.strNum1(arrNum1[len-4])+" thousand ";
        if(!stn.strNum1(arrNum1[len - 3]).equals(""))
        {
        output+=stn.strNum1(arrNum1[len-3])+" hundred ";
        }
        int no1=arrNum1[len-2]*10+arrNum1[len-1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
        }
        System.out.println("output="+output);
        break;
      }

      case 5:
      {
        int no1=arrNum1[len-5]*10+arrNum1[len-4];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1)+" thousand ";
        }
        else
        {
         arrNum1[len-5]=arrNum1[len-5]*10;
         output+=stn.strNum2(arrNum1[len-5]);
         output=output+" "+stn.strNum1(arrNum1[len-4])+" thousand ";
        }
        if( !stn.strNum1(arrNum1[len - 3]).equals(""))
        {
        output+=stn.strNum1(arrNum1[len-3])+" hundred ";
        }
        no1 = arrNum1[len - 2] * 10 + arrNum1[len - 1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
        }
        System.out.println("output="+output);
        break;
      }
      case 6:
      {
        output+=stn.strNum1(arrNum1[len-6])+" million ";
        int no1=arrNum1[len-5]*10+arrNum1[len-4];
        if(no1>=11 & no1<=19)
        {
         output+=stn.strNum2(no1)+" thousand ";
        }
        else
        {
         arrNum1[len-5]=arrNum1[len-5]*10;
         output+=stn.strNum2(arrNum1[len-5]);
         output=output+" "+stn.strNum1(arrNum1[len-4])+" thousand ";
        }
        if( !stn.strNum1(arrNum1[len - 3]).equals(""))
        {
        output+=stn.strNum1(arrNum1[len-3])+" hundred ";
        }
        no1 = arrNum1[len - 2] * 10 + arrNum1[len - 1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
        }
        System.out.println("output="+output);
        break;
      }
      case 7:
      {
        int no1=arrNum1[len-7]*10+arrNum1[len-6];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1)+" Milloin ";
        }
        else
        {
         arrNum1[len-7]=arrNum1[len-7]*10;
         output+=stn.strNum2(arrNum1[len-7]);
         output=output+" "+stn.strNum1(arrNum1[len-6])+" Million ";
        }
        no1=arrNum1[len-5]*10+arrNum1[len-4];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1)+" Thousand ";
        }
        else
        {
         arrNum1[len-5]=arrNum1[len-5]*10;
         output+=stn.strNum2(arrNum1[len-5]);
         output=output+" "+stn.strNum1(arrNum1[len-4])+" Thousand ";
        }
        if( !stn.strNum1(arrNum1[len - 3]).equals(""))
        {
        output+=stn.strNum1(arrNum1[len-3])+" Hundred ";
        }
        no1 = arrNum1[len - 2] * 10 + arrNum1[len - 1];
        if(no1>=11 & no1<=19)
        {
         output=stn.strNum2(no1);
        }
        else
        {
         arrNum1[len-2]=arrNum1[len-2]*10;
         output+=stn.strNum2(arrNum1[len-2]);
         output=output+" "+stn.strNum1(arrNum1[len-1]);
        }
        System.out.println("output="+output);
        break;
      }
    }

  }
  String strNum1(int a)
  {
    String op="";
    switch(a)
    {
     case 1:
     {
     op="one";
     break;
     }
     case 2:
     {
     op="two";
     break;
     }
     case 3:
     {
     op="three";
     break;
     }
     case 4:
     {
     op="four";
     break;
     }
     case 5:
     {
     op="five";
     break;
     }
     case 6:
     {
     op="six";
     break;
     }
     case 7:
     {
     op="seven";
     break;
     }
     case 8:
     {
     op="eight";
     break;
     }
     case 9:
     {
     op="nine";
     break;
     }
    }
    return op;
  }
  String strNum2(int a)
  {
    String op="";
    switch(a)
    {
     case 10:
     {
     op="ten";
     break;
     }
     case 20:
     {
     op="twenty";
     break;
     }
     case 30:
     {
     op="thirty";
     break;
     }
     case 40:
     {
     op="fourty";
     break;
     }
     case 50:
     {
     op="fifty";
     break;
     }
     case 60:
     {
     op="sixty";
     break;
     }
     case 70:
     {
     op="seventy";
     break;
     }
     case 80:
     {
     op="eighty";
     break;
     }
     case 90:
     {
     op="ninty";
     break;
     }
     case 11:
     {
     op="eleven";
     break;
     }
     case 12:
     {
     op="twelve";
     break;
     }
     case 13:
     {
     op="thirteen";
     break;
     }
     case 14:
     {
     op="fourteen";
     break;
     }
     case 15:
     {
     op="fifteen";
     break;
     }
     case 16:
     {
     op="sixteen";
     break;
     }
     case 17:
     {
     op="seventeen";
     break;
     }
     case 18:
     {
     op="eighteen";
     break;
     }
     case 19:
     {
     op="nineteen";
     break;
     }
    }
    return op;
  }
}

J'ai utilisé un tableau à 2 dimensions...

   import java.util.Scanner;


   public class numberEnglish {
   public static void main(String args[])
        {
    String[ ][ ] aryNumbers = new String[9][4];
    aryNumbers[0][0] = "one";
    aryNumbers[0][1] = "ten";
    aryNumbers[0][2] = "one hundred and";
    aryNumbers[0][3] = "one thousand";

    aryNumbers[1][0] = "two";
    aryNumbers[1][1] = "twenty";
    aryNumbers[1][2] = "two hundred and";
    aryNumbers[1][3] = "two thousand";

    aryNumbers[2][0] = "three";
    aryNumbers[2][1] = "thirty";
    aryNumbers[2][2] = "three hundred and";
    aryNumbers[2][3] = "three thousand";

    aryNumbers[3][0] = "four";
    aryNumbers[3][1] = "fourty";
    aryNumbers[3][2] = "four hundred and";
    aryNumbers[3][3] = "four thousand";

    aryNumbers[4][0] = "five";
    aryNumbers[4][1] = "fifty";
    aryNumbers[4][2] = "five hundred and";
    aryNumbers[4][3] = "five thousand";

    aryNumbers[5][0] = "six";
    aryNumbers[5][1] = "sixty";
    aryNumbers[5][2] = "six hundred and";
    aryNumbers[5][3] = "six thousand";

    aryNumbers[6][0] = "seven";
    aryNumbers[6][1] = "seventy";
    aryNumbers[6][2] = "seven hundred and";
    aryNumbers[6][3] = "seven thousand";

    aryNumbers[7][0] = "eight";
    aryNumbers[7][1] = "eighty";
    aryNumbers[7][2] = "eight hundred and";
    aryNumbers[7][3] = "eight thousand";

    aryNumbers[8][0] = "nine";
    aryNumbers[8][1] = "ninty";
    aryNumbers[8][2] = "nine hundred and";
    aryNumbers[8][3] = "nine thousand";


    //System.out.println(aryNumbers[0] + " "+aryNumbers[0] + " ");

    int number=0;
    Scanner sc = new Scanner(System.in);
    System.out.println(" Enter Number 4 digited number:: ");
    number = sc.nextInt();
    int temp = number;
    int count=1;
    String english="";
    String tenglish = "";
    if(number == 0)
    {
        System.out.println("*********");
        System.out.println("Zero");
        System.out.println("*********");
        sc.close();
        return;
    }
    while(temp !=0)
    {

        int r = temp%10;
        if(r==0)
        {
            tenglish = " zero ";
            count++;
        }
        else
        {

            int t1=r-1;
            int t2 = count-1;
            //System.out.println(t1 +" "+t2);
            count++;
            tenglish = aryNumbers[t1][t2];

            //System.out.println(aryNumbers[t1][t2]);
        }
        english = tenglish +" "+ english;
        temp = temp/10;

    }
    //System.out.println(aryNumbers[0][0]);
    english = english.replace("ten  zero", "ten");
    english = english.replace("twenty  zero", "twenty");
    english = english.replace("thirty  zero", "thirty");
    english = english.replace("fourty  zero", "fourty");
    english = english.replace("fifty  zero", "fifty");
    english = english.replace("sixty  zero", "sixty");
    english = english.replace("seventy  zero", "seventy");
    english = english.replace("eighty  zero", "eighty");
    english = english.replace("ninety  zero", "ninety");

    english = english.replace("ten one", "eleven");
    english = english.replace("ten two", "twelve");
    english = english.replace("ten three", "thirteen");
    english = english.replace("ten four", "fourteen");
    english = english.replace("ten five", "fifteen");
    english = english.replace("ten six", "sixteen");
    english = english.replace("ten seven", "seventeen");
    english = english.replace("ten eight", "eighteen");
    english = english.replace("ten nine", "nineteen");
    english = english.replace(" zero ", "");
    int length = english.length();
    String sub = english.substring(length-6,length-3);
    //System.out.println(length);
    //System.out.println(sub);
    if(sub.equals("and"))
    {
        //System.out.println("hello");
        english=english.substring(0,length-6);
    }
    System.out.println("********************************************");
    System.out.println(english);
    System.out.println("********************************************");
    sc.close();
}

}