What is the most elegant way to convert a hyphen separated word (e.g. “do-some-stuff”) to the lower camel-case variation (e.g. “doSomeStuff”)?

Question

What is the most elegant way to convert a hyphen separated word (e.g. \"do-some-stuff\") to the lower camel-case variation (e.g. \"doSomeStuff\") in Java?

Answer 1

If you don't like to depend on a library you can use a combination of a regex and String.format. Use a regex to extract the starting characters after the -. Use these as input for String.format. A bit tricky, but works without a (explizit) loop ;).

public class Test {

    public static void main(String[] args) {
        System.out.println(convert("do-some-stuff"));
    }

    private static String convert(String input) {
        return String.format(input.replaceAll("\\-(.)", "%S"), input.replaceAll("[^-]*-(.)[^-]*", "$1-").split("-"));
    }

}

Answer 2

Use CaseFormat from Guava:

import static com.google.common.base.CaseFormat.*;

String result = LOWER_HYPHEN.to(LOWER_CAMEL, "do-some-stuff");

Answer 3

Why not try this:

1. split on "-"
2. uppercase each word, skipping the first
3. join

EDIT: On second thoughts... While trying to implement this, I found out there is no simple way to join a list of strings in Java. Unless you use StringUtil from apache. So you will need to create a StringBuilder anyway and thus the algorithm is going to get a little ugly :(

CODE: Here is a sample of the above mentioned aproach. Could someone with a Java compiler (sorry, don't have one handy) test this? And benchmark it with other versions found here?

public static String toJavaMethodNameWithSplits(String xmlMethodName)
{
    String[] words = xmlMethodName.split("-"); // split on "-"
    StringBuilder nameBuilder = new StringBuilder(xmlMethodName.length());
    nameBuilder.append(words[0]);
    for (int i = 1; i < words.length; i++) // skip first
    {
        nameBuilder.append(words[i].substring(0, 1).toUpperCase());
        nameBuilder.append(words[i].substring(1));
    }
    return nameBuilder.toString(); // join
}

Answer 4

The following method should handle the task quite efficient in O(n). We just iterate over the characters of the xml method name, skip any '-' and capitalize chars if needed.

public static String toJavaMethodName(String xmlmethodName) { 
  StringBuilder nameBuilder = new StringBuilder(xmlmethodName.length());    
  boolean capitalizeNextChar = false;

  for (char c:xmlMethodName.toCharArray()) {
    if (c == '-') {
      capitalizeNextChar = true;
      continue;
    }
    if (capitalizeNextChar) {
      nameBuilder.append(Character.toUpperCase(c));
    } else {
      nameBuilder.append(c);
    }
    capitalizeNextChar = false;
  }
  return nameBuilder.toString();
}

Answer 5

Iterate through the string. When you find a hypen, remove it, and capitalise the next letter.

Answer 6

In case you use Spring Framework, you can use provided StringUtils.

import org.springframework.util.StringUtils;

import java.util.Arrays;
import java.util.stream.Collectors;

public class NormalizeUtils {

    private static final String DELIMITER = "_";    

    private NormalizeUtils() {
        throw new IllegalStateException("Do not init.");
    }

    /**
     * Take name like SOME_SNAKE_ALL and convert it to someSnakeAll
     */
    public static String fromSnakeToCamel(final String name) {
        if (StringUtils.isEmpty(name)) {
            return "";
        }

        final String allCapitalized = Arrays.stream(name.split(DELIMITER))
                .filter(c -> !StringUtils.isEmpty(c))
                .map(StringUtils::capitalize)
                .collect(Collectors.joining());

        return StringUtils.uncapitalize(allCapitalized);
    }
}