String capitalize - mejor manera

Question

¿Qué método de capitalización es mejor?

mía:

char[] charArray = string.toCharArray(); 
charArray[0] = Character.toUpperCase(charArray[0]); 
return new String(charArray);

o

Commons Lang - StringUtils.capitalize:

return new StringBuffer(strLen) 
      .append(Character.toTitleCase(str.charAt(0))) 
      .append(str.substring(1)) 
      .toString();

Creo que el mío es mejor, pero yo prefiero preguntar.

Answer 1

El rendimiento es el mismo.

Su código copia el número de llamada [] llamando al string.toCharArray() y new String(charArray).

El código de apache en buffer.append(str.substring(1)) y buffer.toString(). El código de apache tiene una instancia de cadena adicional que tiene el contenido de char base [1, length]. Pero esto no se copiará cuando se cree la Cadena de instancia.

Answer 2

¿Ha cronometrado ambos?

Honestamente, son equivalentes .. así que el que funciona mejor para usted es el mejor uno :)

Answer 3

StringBuffer se declara ser seguro para subprocesos, por lo que podría ser menos eficaz de utilizar (pero no se debe apostar antes de hacer algunas pruebas prácticas).

Answer 4

Supongo que su versión será un poco más eficiente, ya que no asigna tantos objetos String temporales.

me gustaría ir para esto (suponiendo que la cadena no está vacía):

StringBuilder strBuilder = new StringBuilder(string); 
strBuilder.setCharAt(0, Character.toUpperCase(strBuilder.charAt(0)))); 
return strBuilder.toString(); 

Sin embargo, tenga en cuenta que no son equivalentes porque se utiliza toUpperCase() y los otros usos toTitleCase().

Desde un forum post:

TitleCase <> mayúsculas
Unicode define tres tipos de mapeo caso: minúsculas, mayúsculas, y TitleCase. La diferencia entre uppercasing y titlecasing un carácter o caracteres secuencia se puede ver en compuesto personajes (es decir, una sola caracteres que representa un compount de dos caracteres).

Por ejemplo, en Unicode, el carácter U + 01F3 es LETRA PEQUEÑA LETRA DZ. (Deje escribir este carácter compuesto usando ASCII como "dz".) Este carácter
mayúsculas en el carácter U + 01F1, LATINO LETRA MAYÚSCULA DZ. (Que es básicamente
"DZ".) Pero titlecases a de carácter U + 01F2, latina mayúscula
letra D CON LETRA Z. (¿Qué podemos escribir "Dz".)

character uppercase titlecase 
--------- --------- --------- 
dz  DZ  Dz 

Answer 5

No estoy seguro de cuál es la diferencia entre toUpperCase y toTitleCase, pero parece que su solución requiere una instanciación menos de la clase String, mientras que la implementación commons lang requiere dos (substring y toString create New Strings, dado que String es inmutable).

Si eso es "mejor" (supongo que quieres decir más rápido) no lo sé. ¿Por qué no perfilas ambas soluciones?

Answer 6

StringBuilder (desde Java 5 en adelante) es más rápido que StringBuffer si no necesita que sea seguro para subprocesos, pero como otros han dicho, debe probar si es mejor que su solución en su caso.

Answer 7

mira esta pregunta titlecase-conversion. apache FTW.

Answer 8

Si tuviera que escribir una biblioteca, trataría de asegurarme de tener mi Unicode correcto antes de preocuparse por el rendimiento. De la parte superior de mi cabeza:

int len = str.length(); 
if (len == 0) { 
    return str; 
} 
int head = Character.toUpperCase(str.codePointAt(0)); 
String tail = str.substring(str.offsetByCodePoints(0, 1)); 
return new String(new int[] { head }).concat(tail); 

(. Me probablemente también miro la diferencia entre el título y en mayúsculas antes de que cometí)

Answer 9

uso de este método para la capitalización de la cadena. su trabajo totalmente sin ningún fallo

public String capitalizeString(String value) 
{ 
    String string = value; 
    String capitalizedString = ""; 
    System.out.println(string); 
    for(int i = 0; i < string.length(); i++) 
    { 
     char ch = string.charAt(i); 
     if(i == 0 || string.charAt(i-1)==' ') 
      ch = Character.toUpperCase(ch); 
     capitalizedString += ch; 
    } 
    return capitalizedString; 
} 

Answer 10

/** 
    * capitalize the first letter of a string 
    * 
    * @param String 
    * @return String 
    * */ 
    public static String capitalizeFirst(String s) { 
     if (s == null || s.length() == 0) { 
      return ""; 
     } 
     char first = s.charAt(0); 
     if (Character.isUpperCase(first)) { 
      return s; 
     } else { 
      return Character.toUpperCase(first) + s.substring(1); 
     } 
    } 

Answer 11

Si sólo provecho expresa limitados, es mejor que la memoria caché.

@Test 
public void testCase() 
{ 
    String all = "At its base, a shell is simply a macro processor that executes commands. The term macro processor means functionality where text and symbols are expanded to create larger expressions.\n" + 
      "\n" + 
      "A Unix shell is both a command interpreter and a programming language. As a command interpreter, the shell provides the user interface to the rich set of GNU utilities. The programming language features allow these utilities to be combined. Files containing commands can be created, and become commands themselves. These new commands have the same status as system commands in directories such as /bin, allowing users or groups to establish custom environments to automate their common tasks.\n" + 
      "\n" + 
      "Shells may be used interactively or non-interactively. In interactive mode, they accept input typed from the keyboard. When executing non-interactively, shells execute commands read from a file.\n" + 
      "\n" + 
      "A shell allows execution of GNU commands, both synchronously and asynchronously. The shell waits for synchronous commands to complete before accepting more input; asynchronous commands continue to execute in parallel with the shell while it reads and executes additional commands. The redirection constructs permit fine-grained control of the input and output of those commands. Moreover, the shell allows control over the contents of commands’ environments.\n" + 
      "\n" + 
      "Shells also provide a small set of built-in commands (builtins) implementing functionality impossible or inconvenient to obtain via separate utilities. For example, cd, break, continue, and exec cannot be implemented outside of the shell because they directly manipulate the shell itself. The history, getopts, kill, or pwd builtins, among others, could be implemented in separate utilities, but they are more convenient to use as builtin commands. All of the shell builtins are described in subsequent sections.\n" + 
      "\n" + 
      "While executing commands is essential, most of the power (and complexity) of shells is due to their embedded programming languages. Like any high-level language, the shell provides variables, flow control constructs, quoting, and functions.\n" + 
      "\n" + 
      "Shells offer features geared specifically for interactive use rather than to augment the programming language. These interactive features include job control, command line editing, command history and aliases. Each of these features is described in this manual."; 
    String[] split = all.split("[\\W]"); 

    // 10000000 
    // upper Used 606 
    // hash Used 114 

    // 100000000 
    // upper Used 5765 
    // hash Used 1101 

    HashMap<String, String> cache = Maps.newHashMap(); 

    long start = System.currentTimeMillis(); 
    for (int i = 0; i < 100000000; i++) 
    { 

     String upper = split[i % split.length].toUpperCase(); 

//   String s = split[i % split.length]; 
//   String upper = cache.get(s); 
//   if (upper == null) 
//   { 
//    cache.put(s, upper = s.toUpperCase()); 
// 
//   } 
    } 
    System.out.println("Used " + (System.currentTimeMillis() - start)); 
} 

El texto es elegido del here.

Actualmente, necesito mayúsculas para el nombre y las columnas de la tabla, muchas muchas veces más, pero son limitados. Usar el hashMap para caché será mejor.

:-)