Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

## 1. Overview

Usually, when we talk about converting an int number to a char, we’ll perform the conversion based on the target char‘s ASCII code.

However, in this tutorial, we’ll look at a different scenario of converting an int value to a letter character.

## 2. Introduction to the Problem

We know there are 26 letters in the English alphabet: A, B, C, …, X, Y, Z.

Now, let’s say we’re receiving an integer. Our task is to convert the integer into an English letter following these rules:

• Integer -> Letter:
• 0 -> A
• 1 -> B
• 2 -> C
• 10 -> K
• 23 -> X
• 24 -> Y
• 25 -> Z

Of course, the integer we received may be out of the range [0, 25]. If this is the case, we have a few options, depending on our requirements:

• Throw an exception
• Return a null value
• Return a particular character as the fallback, for example, “?” or “-“

In this tutorial, we’ll take the last approach above, returning the “?” character if the input integer is out of the range [0, 25].

So next, let’s build methods to solve this interesting problem. For simplicity, we’ll use unit test assertions to verify whether our solution works as expected.

## 3. Picking the Letter From a Sequence

If we consider the conversion rule, we may find the relationship between the integer and the associated letter. The input integers are the indexes if we put the letters A – Z in a list or array. Of course, we still need to handle the “out-of-range” case.

However, using List may bring additional overhead. To make it simple, we’ll create a String constant containing “ABC…Z” and use the standard subString() method to pick the target letter from the string:

``````static char numToLetterBySubstr(int i) {
String LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (i > 0 && i <= 25) {
return LETTERS.substring(i, i + 1).charAt(0);
} else {
return '?';
}
}``````

As we can see in the implementation above, we first check the input integer’s range. We return the ‘?‘ character if the input falls out of the target range. Otherwise, we pick the correct letter by calling the substring() method.

It’s worth mentioning that the substring() method’s second parameter is the endIndex. Further, the endIndex-referenced value is excluded from the result. Therefore, substring(i, i+1) returns the letter with the index i.

Next, let’s write a test to verify if this method works correctly:

``````char negativeInputResult = numToLetterBySubstr(-7);
assertEquals('?', negativeInputResult);

char tooLargeInputResult = numToLetterBySubstr(42);
assertEquals('?', tooLargeInputResult);

char result = numToLetterBySubstr(10);
assertEquals('K', result);``````

We have covered two scenarios involving input values both within and outside the range of 0 to 25.

The test passes if we execute it.

## 4. The ‘A’ + Offset Approach

We’ve seen the straightforward solution with a predefined letter sequence and picking the target letter by the index. Alternatively, we can save the predefined letter sequence and make use of the char values of the letters to solve the problem.

In other words, we take the letter ‘A‘ as the base. So, if the input integer is in the range of 0 to 25, we can treat it as the offset to the ‘A‘ character. Thus, ‘A’ + input will be the letter we’re looking for.

But ‘A’ + int will result in an int. So, we need to cast it to char. Of course, we shouldn’t forget to handle the “input out of range” case:

``````static char numToLetterByAsciiCode(int i) {
if (i > 0 && i <= 25) {
return (char) ('A' + i);
} else {
return '?';
}
}``````

Next, let’s test if it works as expected:

``````char negativeInputResult = numToLetterByAsciiCode(-7);
assertEquals('?', negativeInputResult);

char tooLargeInputResult = numToLetterByAsciiCode(42);
assertEquals('?', tooLargeInputResult);

char charResult = numToLetterByAsciiCode(10);
assertEquals('K', charResult);``````

If we run the test, it passes. So, the method solves the problem.

It’s worth mentioning that the return type of the method is char instead of String. If the String type is required, we can simply convert the char to String using the String.valueOf() method to get the letter in String:

``assertEquals("K", String.valueOf(charResult));``

## 5. Conclusion

In this article, we’ve solved an interesting problem: converting an integer to an English letter.

We’ve implemented two methods to solve it:

• Picking the letter from a predefined letter sequence
• Taking the character ‘A‘ as the base, get the result by ‘A’ + offset

As usual, all code snippets presented here are available over on GitHub.

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.