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");