Converting Integers to Roman Numerals in Java

As a senior Java developer, I often come across situations where I need to convert numbers into their Roman numeral representations. While it may seem like a simple task, understanding Roman numeral conventions and implementing a reliable solution requires some thought. In this blog post, I'll walk you through a Java program that effectively converts integers to Roman numerals.

Roman Numerals Overview

Roman numerals are represented by combinations of letters from the Latin alphabet. The basic Roman numeral symbols and their values are as follows:

• I = 1
• V = 5
• X = 10
• L = 50
• C = 100
• D = 500
• M = 1000

The rules for combining these symbols are as follows:

1. Symbols are written from largest to smallest from left to right.
2. If a smaller numeral appears before a larger one, it is subtracted (e.g., IV = 4).
3. If a smaller numeral appears after a larger one, it is added (e.g., VI = 6).

Conversion Logic

To convert an integer to a Roman numeral, we can use a greedy algorithm. We'll start with the largest value and work our way down, subtracting from the integer and appending the corresponding Roman numeral until we've completely converted the number.

Java Implementation

Here's a Java program that implements this logic:

import java.util.LinkedHashMap;
import java.util.Map;

public class IntegerToRoman {
    // Mapping of integer values to their corresponding Roman numeral representations
    private static final LinkedHashMap<Integer, String> romanMap = new LinkedHashMap<>();

    static {
        romanMap.put(1000, "M");
        romanMap.put(900, "CM");
        romanMap.put(500, "D");
        romanMap.put(400, "CD");
        romanMap.put(100, "C");
        romanMap.put(90, "XC");
        romanMap.put(50, "L");
        romanMap.put(40, "XL");
        romanMap.put(10, "X");
        romanMap.put(9, "IX");
        romanMap.put(5, "V");
        romanMap.put(4, "IV");
        romanMap.put(1, "I");
    }

    public static String intToRoman(int num) {
        StringBuilder romanNumeral = new StringBuilder();

        for (Map.Entry<Integer, String> entry : romanMap.entrySet()) {
            while (num >= entry.getKey()) {
                romanNumeral.append(entry.getValue());
                num -= entry.getKey();
            }
        }
        return romanNumeral.toString();
    }

    public static void main(String[] args) {
        int number = 1987; // Example number
        String romanNumeral = intToRoman(number);
        System.out.println("The Roman numeral for " + number + " is: " + romanNumeral);
    }
}

Explanation of the Code

1. Roman Mapping: We create a LinkedHashMap to store integer values and their corresponding Roman numeral strings. The order of insertion matters here because we want to process larger values first.
2. intToRoman Method: This method takes an integer as input and constructs the Roman numeral representation. It iterates over the map entries, checking if the current number can accommodate the mapped integer value. If it can, it appends the corresponding Roman numeral to the result and subtracts the integer value from the number.
3. Main Method: Here, we test our method with a sample number, 1987, and print the resulting Roman numeral.

Output

Running the program with the number 1987 will yield the output:

The Roman numeral for 1987 is: MCMLXXXVII

Conclusion

Converting integers to Roman numerals is a straightforward but insightful exercise in algorithm design. The method we've implemented is efficient and easily extensible for future modifications. You can further enhance the program by adding input validation or handling numbers outside the conventional Roman numeral range (1-3999).

Feel free to experiment with the code and explore more about Roman numeral systems. Happy coding!