java - descargar - ¿Cuál es la forma más elegante de convertir una palabra separada por guiones(por ejemplo, "do-some-stuff") en la variación más baja de camello(por ejemplo, "doSomeStuff")?

java offline

Question

¿Cuál es la forma más elegante de convertir una palabra separada por guiones (p. Ej., "Do-some-stuff") en la variación inferior de camello (por ejemplo, "doSomeStuff") en Java?

Answer 1

Aquí hay una pequeña variación de la respuesta de Andreas que hace más de lo que el OP solicitó:

public static String toJavaMethodName(final String nonJavaMethodName){
    final StringBuilder nameBuilder = new StringBuilder();
    boolean capitalizeNextChar = false;
    boolean first = true;

    for(int i = 0; i < nonJavaMethodName.length(); i++){
        final char c = nonJavaMethodName.charAt(i);
        if(!Character.isLetterOrDigit(c)){
            if(!first){
                capitalizeNextChar = true;
            }
        } else{
            nameBuilder.append(capitalizeNextChar
                ? Character.toUpperCase(c)
                : Character.toLowerCase(c));
            capitalizeNextChar = false;
            first = false;
        }
    }
    return nameBuilder.toString();
}

Maneja algunos casos especiales:

• fUnnY-cASe se convierte en funnyCase
• --dash-before-and--after- dashBeforeAndAfter se convierte a dashBeforeAndAfter
• some.other$funky:chars? se convierte en someOtherFunkyChars

Answer 2

Como no soy un gran fan de agregar una biblioteca solo por un método, implementé mi propia solución (desde camel case hasta snake case):

public String toSnakeCase(String name) {
    StringBuilder buffer = new StringBuilder();
    for(int i = 0; i < name.length(); i++) {
        if(Character.isUpperCase(name.charAt(i))) {
            if(i > 0) {
                buffer.append(''_'');
            }
            buffer.append(Character.toLowerCase(name.charAt(i)));
        } else {
            buffer.append(name.charAt(i));
        }
    }
    return buffer.toString();
}

Necesita ser adaptado dependiendo de los casos de entrada / salida.

Answer 3

Con Java 8, finalmente hay una sola línea :

Arrays.stream(name.split("//-"))
    .map(String::toLowerCase)
    .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
    .collect(Collectors.joining());

Aunque se necesita dividir en 4 líneas reales para ser legible ツ

(Nota: "//-" es para kebab-case según la pregunta, para snake_case simplemente cambie a "_" )

Answer 4

El siguiente método debe manejar la tarea bastante eficiente en O (n). Simplemente iteramos sobre los caracteres del nombre del método xml, omitimos cualquier ''-'' y capitalizamos los caracteres si es necesario.

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

Itera a través de la cadena. Cuando encuentres un hypen, quítalo y escribe en mayúscula la próxima letra.

Answer 6

Para aquellos que tengan la biblioteca com.fasterxml.jackson en el proyecto y no quieran agregar guayaba, pueden usar el método jaskson namingStrategy:

new PropertyNamingStrategy.SnakeCaseStrategy.translate(String);

Answer 7

Por qué no probar esto:

1. dividido en "-"
2. en mayúsculas cada palabra, omitiendo la primera
3. unirse

EDITAR : En segundos ... Al tratar de implementar esto, descubrí que no hay una forma simple de unirse a una lista de cadenas en Java. A menos que use StringUtil de apache. Así que tendrás que crear un StringBuilder todos modos y así el algoritmo se pondrá un poco feo :(

CÓDIGO : Aquí hay una muestra del enfoque mencionado anteriormente. ¿Podría alguien con un compilador de Java (lo siento, no tengo uno a mano) probar esto? Y compararlo con otras versiones que se encuentran aquí?

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 8

Si no desea depender de una biblioteca, puede usar una combinación de String.format regulares y String.format . Use una expresión regular para extraer los caracteres iniciales después de - . Úselos como entrada para String.format . Un poco complicado, pero funciona sin un bucle (explizit);).

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 9

obtener el contenedor de Apache commons para StringUtils. Entonces puedes usar el método capitalizar

import org.apache.commons.lang.StringUtils;
public class MyClass{

    public String myMethod(String str) {
        StringBuffer buff = new StringBuffer();

        String[] tokens = str.split("-");
        for (String i : tokens) {
            buff.append(StringUtils.capitalize(i));
        }

        return buff.toString();
    }
}

Answer 10

Use CaseFormat de Guava :

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

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