Convert a String to Camel Case

1. Overview

Camel case and title case are commonly used as identifiers for fields and types. We may wish to convert text into this format.

This can be achieved either by writing custom code or by making use of third-party libraries.

In this tutorial, we'll look at how to write some custom string conversions to camel cases, and we'll explore some third-party library features that can help us with that task.

2. Java Solutions

Camel's case allows us to join multiple words by removing whitespace and using capital letters to show word boundaries. 

There are two types:

• Lower camel case, where the first character of the first word is in lowercase
• Upper camel case, also known as title case, where the first character of the first word is in uppercase:

thisIsLowerCamelCase
ThisIsLowerCamelCase

In this tutorial, we'll focus on conversion to lower camel case, though these techniques are easily adapted to suit either.

2.1. Regular Expression (Regex)

We can use regular expressions to split our string containing words into an array:

String[] words = text.split("[\\W_]+");

This splits the given string at any character that's not part of a word. The underscore is normally considered a word character in regular expressions. Camel's case does not include underscore, so we've added that to the delimiter expression.

When we have the separate words, we can modify their capitalization and reassemble them as camel cases:

StringBuilder builder = new StringBuilder();
for (int i = 0; i < words.length; i++) {
    String word = words[i];
    if (i == 0) {
        word = word.isEmpty() ? word : word.toLowerCase();
    } else {
        word = word.isEmpty() ? word : Character.toUpperCase(word.charAt(0)) + word.substring(1).toLowerCase();      
    }
    builder.append(word);
}
return builder.toString();

Here, we convert the first string/word in the array to lowercase. For every other word in the array, we convert the first character to uppercase and the rest to lowercase.

Let's test this method using white space as the non-word characters:

assertThat(toCamelCaseByRegex("THIS STRING SHOULD BE IN CAMEL CASE"))
  .isEqualTo("thisStringShouldBeInCamelCase");

This solution is straightforward, but it requires a few copies of the original text in order to calculate the answer. First, it creates a list of the words, then creates copies of those words in various capitalized or lowercase formats to compose the final string. This may consume a lot of memory with very large input.

2.2. Iterating Through the String

We could replace the above algorithm with a loop that works out the correct case of each character as it passes through the original string. This skips any delimiters and writes one character at a time to the StringBuilder.

First, we need to track the state of the conversion:

boolean shouldConvertNextCharToLower = true;

Then we iterate through the source text, skipping or appropriately capitalizing each character:

for (int i = 0; i < text.length(); i++) {
    char currentChar = text.charAt(i);
    if (currentChar == delimiter) {
        shouldConvertNextCharToLower = false;
    } else if (shouldConvertNextCharToLower) {
        builder.append(Character.toLowerCase(currentChar));
    } else {
        builder.append(Character.toUpperCase(currentChar));
        shouldConvertNextCharToLower = true;
    }
}
return builder.toString();

The delimiter character here is a char that represents the expected non-word character.

Let's try this solution using space as the delimiter:

assertThat(toCamelCaseByIteration("THIS STRING SHOULD BE IN CAMEL CASE", ' '))
  .isEqualTo("thisStringShouldBeInCamelCase");

We can also try it with an underscore delimiter:

assertThat(toCamelCaseByIteration("THIS_STRING_SHOULD_BE_IN_CAMEL_CASE", '_'))
  .isEqualTo("thisStringShouldBeInCamelCase");

3. Using Third-Party Libraries

We may prefer to use third-party library string functions, rather than write our own.

3.1. Apache Commons Text

To use Apache Commons Text, we need to add it to our project:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-text</artifactId>
    <version>1.9</version>
</dependency>

This library provides a toCamelCase method in CaseUtils:

String camelCase = CaseUtils.toCamelCase(text, false, delimiter);

Let's try it out:

assertThat(CaseUtils.toCamelCase("THIS STRING SHOULD BE IN CAMEL CASE", false, ' '))
  .isEqualTo("thisStringShouldBeInCamelCase");

In order to turn the string to title case or upper camel case, we need to pass true into the toCamelCase method:

String camelCase = CaseUtils.toCamelCase(text, true, delimiter);

Let's try it out:

assertThat(CaseUtils.toCamelCase("THIS STRING SHOULD BE IN CAMEL CASE", true, ' '))
  .isEqualTo("ThisStringShouldBeInCamelCase");

3.2. Guava

With a little pre-processing, we can convert a string to camel via Guava.

To use Guava, let's add its dependency to our project:

<dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>28.1-jre</version>
</dependency>

Guava has a utility class, CaseFormat, for format conversion:

String camelCase = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "THIS_STRING_SHOULD_BE_IN_CAMEL_CASE");

This converts a given uppercase string separated by underscores to a lower camel case. Let's see it:

assertThat(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "THIS_STRING_SHOULD_BE_IN_CAMEL_CASE"))
  .isEqualTo("thisStringShouldBeInCamelCase");

This is fine if our string is already in this format. However, if we wish to use a different delimiter and handle mixed cases, we'll need to pre-process our input:

String toUpperUnderscore = "This string should Be in camel Case"
  .toUpperCase()
  .replaceAll(' ', "_");

First, we convert the given string to uppercase. Then, we replace all the separators with underscores. The resulting format is the equivalent of Guava's CaseFormat.UPPER_UNDERSCORE. Now we can use Guava to produce the camel case version:

assertThat(toCamelCaseUsingGuava("THIS STRING SHOULD BE IN CAMEL CASE", " "))
  .isEqualTo("thisStringShouldBeInCamelCase");

4. Conclusion

In this tutorial, we've learned how to convert a string to a camel case.

First, we built an algorithm to split the string into words. Then we built an algorithm that iterated over each character.

Finally, we looked at how to use some third-party libraries to achieve the result. Apache Commons Text was a close match, and Guava could help us after some pre-processing.

As usual, the complete source code is available over on GitHub.