Преобразование Римский цифр в Арабские и обратно. Вопрос.

 public class RomanNumeral {
    
       private final int num;   // The number represented by this Roman numeral.
       
       /* The following arrays are used by the toString() function to construct
          the standard Roman numeral representation of the number.  For each i,
          the number numbers[i] is represented by the corresponding string, letters[i].
       */
       
       private static int[]    numbers = { 1000,  900,  500,  400,  100,   90,  
                                             50,   40,   10,    9,    5,    4,    1 };
                                          
       private static String[] letters = { "M",  "CM",  "D",  "CD", "C",  "XC",
                                           "L",  "XL",  "X",  "IX", "V",  "IV", "I" };
          
    
       public RomanNumeral(int arabic) {
             // Constructor.  Creates the Roman number with the int value specified
             // by the parameter.  Throws a NumberFormatException if arabic is
             // not in the range 1 to 3999 inclusive.
          if (arabic < 1)
             throw new NumberFormatException("Value of RomanNumeral must be positive.");
          if (arabic > 3999)
             throw new NumberFormatException("Value of RomanNumeral must be 3999 or less.");
          num = arabic;
       }
       
    
       public RomanNumeral(String roman) {
             // Constructor.  Creates the Roman number with the given representation.
             // For example, RomanNumeral("xvii") is 17.  If the parameter is not a
             // legal Roman numeral, a NumberFormatException is thrown.  Both upper and
             // lower case letters are allowed.
             
          if (roman.length() == 0)
             throw new NumberFormatException("An empty string does not define a Roman numeral.");
             
          roman = roman.toUpperCase();  // Convert to upper case letters.
          
          int i = 0;       // A position in the string, roman;
          int arabic = 0;  // Arabic numeral equivalent of the part of the string that has
                           //    been converted so far.
          
          while (i < roman.length()) {
          
             char letter = roman.charAt(i);        // Letter at current position in string.
             int number = letterToNumber(letter);  // Numerical equivalent of letter.
             
             if (number < 0)
                throw new NumberFormatException("Illegal character \"" + letter + "\" in roman numeral.");
                
             i++;  // Move on to next position in the string
             
             if (i == roman.length()) {
                   // There is no letter in the string following the one we have just processed.
                   // So just add the number corresponding to the single letter to arabic.
                arabic += number;
             }
             else {
                   // Look at the next letter in the string.  If it has a larger Roman numeral
                   // equivalent than number, then the two letters are counted together as
                   // a Roman numeral with value (nextNumber - number).
                int nextNumber = letterToNumber(roman.charAt(i));
                if (nextNumber > number) {
                      // Combine the two letters to get one value, and move on to next position in string.
                   arabic += (nextNumber - number);
                   i++;
                }
                else {
                      // Don't combine the letters.  Just add the value of the one letter onto the number.
                   arabic += number;
                }
             }
             
          }  // end while
          
          if (arabic > 3999)
             throw new NumberFormatException("Roman numeral must have value 3999 or less.");
             
          num = arabic;
          
       } // end constructor
       
    
       private int letterToNumber(char letter) {
             // Find the integer value of letter considered as a Roman numeral.  Return
             // -1 if letter is not a legal Roman numeral.  The letter must be upper case.
          switch (letter) {
             case 'I':  return 1;
             case 'V':  return 5;
             case 'X':  return 10;
             case 'L':  return 50;
             case 'C':  return 100;
             case 'D':  return 500;
             case 'M':  return 1000;
             default:   return -1;
          }
       }
       
    
       public String toString() {
             // Return the standard representation of this Roman numeral.
          String roman = "";  // The roman numeral.
          int N = num;        // N represents the part of num that still has
                              //   to be converted to Roman numeral representation.
          for (int i = 0; i < numbers.length; i++) {
             while (N >= numbers[i]) {
                roman += letters[i];
                N -= numbers[i];
             }
          }
          return roman;
       }
       
       public int toInt() {
            // Return the value of this Roman numeral as an int.
          return num;
       }   
    } // end class RomanNumeral

 public class RomanConverter {
    
       public static void main(String[] args) {
          
          TextIO.putln("Enter a Roman numeral and I will convert it to an ordinary");
          TextIO.putln("arabic integer.  Enter an integer in the range 1 to 3999");
          TextIO.putln("and I will convert it to a Roman numeral.  Press return when");
          TextIO.putln("you want to quit.");
          
          while (true) {
    
             TextIO.putln();
             TextIO.put("? ");
             
             /* Skip past any blanks at the beginning of the input line.
                Break out of the loop if there is nothing else on the line. */
             
             while (TextIO.peek() == ' ' || TextIO.peek() == '\t')
                TextIO.getAnyChar();
             if ( TextIO.peek() == '\n' )
                break;
                
             /* If the first non-blank character is a digit, read an arabic
                numeral and convert it to a Roman numeral.  Otherwise, read
                a Roman numeral and convert it to an arabic numeral. */
                
             if ( Character.isDigit(TextIO.peek()) ) {
                int arabic = TextIO.getlnInt();
                try {
                    RomanNumeral N = new RomanNumeral(arabic);
                    TextIO.putln(N.toInt() + " = " + N.toString());
                }
                catch (NumberFormatException e) {
                    TextIO.putln("Invalid input.");
                    TextIO.putln(e.getMessage());
                }
             }
             else {
                String roman = TextIO.getln();
                try {
                    RomanNumeral N = new RomanNumeral(roman);
                    TextIO.putln(N.toString() + " = " + N.toInt());
                }
                catch (NumberFormatException e) {
                    TextIO.putln("Invalid input.");
                    TextIO.putln(e.getMessage());
                }
             }
    
          }  // end while
          
          TextIO.putln("OK.  Bye for now.");
    
       }  // end main()
       
    } // end class RomanConverter