Convert Camel Case to Snake Case in Java

1. Overview

Camel and snake cases are two common naming conventions often used in programming. While the camel case utilizes capital letters to signify the start of a new word (camelCaseExample), the snake case separates words using underscores (snake_case_example).

In this tutorial, we’ll explore how to implement such a conversion in Java.

2. Understanding the Conversion

When converting a camel case string into a snake case one, we need to:

• Identify boundaries between words
• Insert an underscore (`_`) at each boundary
• Make sure all letters are lowercase

For example:

• Input: “convertCamelCase”
• Output: “convert_camel_case”

With this in mind, let’s examine ways to achieve this transformation.

3. Using a Manual Approach

To begin with, the simplest approach involves iterating over the characters in a string and adding underscores when encountering uppercase letters:

public static String convertCamelCaseToSnake(String input) {
    StringBuilder result = new StringBuilder();
    for (char c : input.toCharArray()) {
        if (Character.isUpperCase(c)) {
            result.append("_").append(Character.toLowerCase(c));
        } else {
            result.append(c);
        }
    }
    return result.toString();
}

Let’s now break down what we’re doing in this method:

• Iterate through each character in the string
• When an uppercase letter is encountered, prepend an underscore and convert it to lowercase
• For all other characters, directly append them

Finally, let’s test our implementation:

@Test
public void whenConvertNormalCamelCase_thenGetCorrectSnakeCase() {
    String input = "convertCamelCase";
    String expected = "convert_camel_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnake(input));
}

@Test
public void whenConvertNotNormalCamelCase_thenGetCorrectSnakeCase() {
    String input = "convertCCamelCase";
    String expected = "convert_c_camel_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnake(input));
}

@Test
public void whenConvertAlreadySnakeCase_thenGetUnchangedSnakeCase() {
    String input = "snake_case";
    String expected = "snake_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnake(input));
}

@Test
public void whenConvertAllLowerCaseString_thenGetUnchangedString() {
    String input = "snakecase";
    String expected = "snakecase";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnake(input));
}

@Test
public void whenConvertOtherEdgeCases_thenGetCorrectSnakeCases() {
    // Blank string
    Assertions.assertEquals("", CamelToSnakeCaseConverter.convertCamelCaseToSnake(""));

    // Special character
    String input = "sn@keCase#";
    String expected = "sn@ke_case#";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnake(input));
}

4. Using Regular Expressions

Alternatively, regular expressions simplify the task by defining patterns for uppercase letters and replacing them:

public static String convertCamelCaseToSnakeRegex(String input) {
    return input
      .replaceAll("([A-Z])(?=[A-Z])", "$1_")
      .replaceAll("([a-z])([A-Z])", "$1_$2")
      .toLowerCase();
}

Here’s how it works:

• The replaceAll(“([A-Z])(?=[A-Z])”, “$1_”) method adds an underscore between adjacent uppercase letters.
• The replaceAll(“([a-z])([A-Z])”, “$1_$2”) method adds an underscore before uppercase letters that follow lowercase letters.
• Finally, the entire result is converted to lowercase.

Let’s also verify this method:

@Test
public void whenConvertNormalCamelCase_thenGetCorrectSnakeCase() {
    String input = "convertCamelCase";
    String expected = "convert_camel_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(input));
}

@Test
public void whenConvertNotNormalCamelCase_thenGetCorrectSnakeCase() {
    String input = "convertCCamelCase";
    String expected = "convert_c_camel_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(input));
}

@Test
public void whenConvertAlreadySnakeCase_thenGetUnchangedSnakeCase() {
    String input = "snake_case";
    String expected = "snake_case";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(input));
}

@Test
public void whenConvertAllLowerCaseString_thenGetUnchangedString() {
    String input = "snakecase";
    String expected = "snakecase";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(input));
}

@Test
public void whenConvertOtherEdgeCases_thenGetCorrectSnakeCases() {
    // Blank string
    Assertions.assertEquals("", CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(""));

    // Special character
    String input = "sn@keCase#";
    String expected = "sn@ke_case#";
    Assertions.assertEquals(expected, CamelToSnakeCaseConverter.convertCamelCaseToSnakeRegex(input));
}

5. Handling Edge Cases

When converting camel case strings to snake case, it’s essential to handle various edge cases, such as:

• Empty strings: ensure our function returns an empty string
• All lowercase strings: input should remain unaffected
• Strings already in snake case: ensure the function doesn’t change such strings
• Special characters: they should remain unaffected

6. Conclusion

In conclusion, we explored two approaches to converting camel case to snake case in Java: the manual approach using iteration and the more concise method leveraging regular expressions.