Convert a String to Title Case

1. Introduction

In this short tutorial, we’ll show how to convert a String to title case format in Java.

We’ll show different ways of implementing a custom method and we’ll also show how to do it using third party libraries.

2. Core Java Solutions

2.1. Iterating Through the String Characters

One way to convert a String to title case is by iterating through all the characters of the String.

To do so, when we find a word separator we capitalize the next character. After that, we change the rest of the characters to lower case until we reach the next word separator.

Let’s use a white space as a word separator and implement this solution:

public static String convertToTitleCaseIteratingChars(String text) {
    if (text == null || text.isEmpty()) {
        return text;
    }

    StringBuilder converted = new StringBuilder();

    boolean convertNext = true;
    for (char ch : text.toCharArray()) {
        if (Character.isSpaceChar(ch)) {
            convertNext = true;
        } else if (convertNext) {
            ch = Character.toTitleCase(ch);
            convertNext = false;
        } else {
            ch = Character.toLowerCase(ch);
        }
        converted.append(ch);
    }

    return converted.toString();
}

As we can see, we use the method Character.toTitleCase to do the conversion, since it checks the title case equivalent of a Character in Unicode.

If we test this method using these inputs:

tHis IS a tiTLe
tHis, IS a   tiTLe

We get the following expected outputs:

This Is A Title
This, Is A   Title

2.2. Splitting Into Words

Another approach to do this is to split the String into words, convert every word to title case, and finally join all the words again using the same word separator.

Let’s see it in code, using again the white space as a word separator, and the helpful Stream API:

private static final String WORD_SEPARATOR = " ";

public static String convertToTitleCaseSplitting(String text) {
    if (text == null || text.isEmpty()) {
        return text;
    }

    return Arrays
      .stream(text.split(WORD_SEPARATOR))
      .map(word -> word.isEmpty()
        ? word
        : Character.toTitleCase(word.charAt(0)) + word
          .substring(1)
          .toLowerCase())
      .collect(Collectors.joining(WORD_SEPARATOR));
}

Using the same inputs as before, we get the exact same outputs:

This Is A Title
This, Is A   Title

3. Using Apache Commons

In case we don’t want to implement our own custom method, we can use the Apache Commons library. The setup for this library is explained in this article.

This provides the WordUtils class, that has the capitalizeFully() method which does exactly what we want to achieve:

public static String convertToTileCaseWordUtilsFull(String text) {
    return WordUtils.capitalizeFully(text);
}

As we can see, this is very easy to use and if we test it with the same inputs as before we get the same results:

This Is A Title
This, Is A   Title

Also, the WordUtils class provides another capitalize() method that works similarly to capitalizeFully(), except it only changes the first character of each word. This means that it doesn’t convert the rest of the characters to lower case.

Let’s see how we can use this:

public static String convertToTileCaseWordUtils(String text) {
    return WordUtils.capitalize(text);
}

Now, if we test it with the same inputs as before we get these different outputs:

THis IS A TiTLe
THis, IS A   TiTLe

4. Using ICU4J

Another library that we can use is ICU4J, which provides Unicode and globalization support.

To use it we need to add this dependency to our project:

<dependency>
    <groupId>com.ibm.icu</groupId>
    <artifactId>icu4j</artifactId>
    <version>61.1</version>
</dependency>

The latest version can be found here.

This library works in a very similar way as WordUtils, but we can specify a BreakIterator to tell the method how we want to split the String, and therefore what words we want to convert to title case:

public static String convertToTitleCaseIcu4j(String text) {
    if (text == null || text.isEmpty()) {
        return text;
    }

    return UCharacter.toTitleCase(text, BreakIterator.getTitleInstance());
}

As we can see, they have a specific BreakIterator to work with titles. If we don’t specify any BreakIterator it uses the defaults from Unicode, which in this case generate the same results.

Also, notice that this method lets us specify the Locale of the String we are converting in order to do a locale-specific conversion.

5. Conclusion

In this brief article, we’ve shown how to convert a String to title case format in Java. We’ve used our custom implementations first, and after that, we’ve shown how to do it using external libraries.

As always, the full source code of the examples is available over on GitHub.