¿Cómo convierto una cadena en caso de título en android?

Question

Realicé búsquedas altas y bajas pero solo pude encontrar referencias indirectas a este tipo de preguntas. Al desarrollar una aplicación para Android, si tiene una cadena que ha sido ingresada por el usuario, ¿cómo puede convertirla en mayúscula (es decir, hacer mayúscula la primera letra de cada palabra)? Preferiría no importar una biblioteca completa (como WordUtils de Apache).

Answer 1

me dieron algunas indicaciones desde aquí: Android,need to make in my ListView the first letter of each word uppercase, pero al final, laminado mi propia solución (nota, este enfoque supone que todas las palabras están separadas por un único carácter de espacio, que estaba bien para mis necesidades):

String[] words = input.getText().toString().split(" "); 
StringBuilder sb = new StringBuilder(); 
if (words[0].length() > 0) { 
    sb.append(Character.toUpperCase(words[0].charAt(0)) + words[0].subSequence(1, words[0].length()).toString().toLowerCase()); 
    for (int i = 1; i < words.length; i++) { 
     sb.append(" "); 
     sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase()); 
    } 
} 
String titleCaseValue = sb.toString(); 

... donde la entrada es una vista EditText. También es útil para establecer el tipo de entrada en la vista de forma que el valor predeterminado es el caso del título de todos modos:

input.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS); 

Answer 2

que buscas un Apache de WordUtils.capitalize() method.

Answer 3

esto le ayuda

EditText view = (EditText) find.. 
String txt = view.getText(); 
txt = String.valueOf(txt.charAt(0)).toUpperCase() + txt.substring(1, txt.length()); 

Answer 4

En el XML, puede hacerlo de esta manera:

android:inputType="textCapWords" 

Comprobar la referencia para otras opciones, como el caso de la oración, todas las letras mayúsculas, etc. aquí :

http://developer.android.com/reference/android/widget/TextView.html#attr_android:inputType

Answer 5

acabo de tener el mismo probl em y lo resolvió con esto:

import android.text.TextUtils; 
... 

String[] words = input.split("[.\\s]+"); 

for(int i = 0; i < words.length; i++) { 
    words[i] = words[i].substring(0,1).toUpperCase() 
       + words[i].substring(1).toLowerCase(); 
} 

String titleCase = TextUtils.join(" ", words); 

Tenga en cuenta, en mi caso, que era necesario eliminar los períodos, también. Cualquier carácter que deba reemplazarse con espacios se puede insertar entre los corchetes cuadrados durante la "división". Por ejemplo, la siguiente sería en última instancia reemplazar guiones, puntos, comas o espacios en blanco:

String[] words = input.split("[_.,\\s]+"); 

Esto, por supuesto, se puede lograr mucho más simple con el "non-word character" symbol:

String[] words = input.split("\\W+"); 

Vale la pena mencionar que los números y guiones SON considerados "caracteres de palabras", por lo que esta última versión satisfizo mis necesidades perfectamente y con suerte ayudará a alguien más.

Answer 6

Aquí está el método WordUtils.capitalize() en caso de que no desee importar toda la clase.

public static String capitalize(String str) { 
    return capitalize(str, null); 
} 

public static String capitalize(String str, char[] delimiters) { 
    int delimLen = (delimiters == null ? -1 : delimiters.length); 
    if (str == null || str.length() == 0 || delimLen == 0) { 
     return str; 
    } 
    int strLen = str.length(); 
    StringBuffer buffer = new StringBuffer(strLen); 
    boolean capitalizeNext = true; 
    for (int i = 0; i < strLen; i++) { 
     char ch = str.charAt(i); 

     if (isDelimiter(ch, delimiters)) { 
      buffer.append(ch); 
      capitalizeNext = true; 
     } else if (capitalizeNext) { 
      buffer.append(Character.toTitleCase(ch)); 
      capitalizeNext = false; 
     } else { 
      buffer.append(ch); 
     } 
    } 
    return buffer.toString(); 
} 
private static boolean isDelimiter(char ch, char[] delimiters) { 
    if (delimiters == null) { 
     return Character.isWhitespace(ch); 
    } 
    for (int i = 0, isize = delimiters.length; i < isize; i++) { 
     if (ch == delimiters[i]) { 
      return true; 
     } 
    } 
    return false; 
} 

Espero que ayude.

Answer 7

Por favor, compruebe la siguiente solución que funcione para ambas cadena múltiple y la cadena también única a

String toBeCapped = "i want this sentence capitalized"; 
String[] tokens = toBeCapped.split("\\s"); 

if(tokens.length>0) 
{ 
    toBeCapped = ""; 

    for(int i = 0; i < tokens.length; i++) 
    { 
    char capLetter = Character.toUpperCase(tokens[i].charAt(0)); 
    toBeCapped += " " + capLetter + tokens[i].substring(1, tokens[i].length()); 
    } 
} 
else 
{ 
    char capLetter = Character.toUpperCase(toBeCapped.charAt(0)); 
    toBeCapped += " " + capLetter + toBeCapped .substring(1, toBeCapped .length()); 
} 

Answer 8

Pon esto en su clase de utilidades de texto:

public static String toTitleCase(String str) { 

    if (str == null) { 
     return null; 
    } 

    boolean space = true; 
    StringBuilder builder = new StringBuilder(str); 
    final int len = builder.length(); 

    for (int i = 0; i < len; ++i) { 
     char c = builder.charAt(i); 
     if (space) { 
      if (!Character.isWhitespace(c)) { 
       // Convert to title case and switch out of whitespace mode. 
       builder.setCharAt(i, Character.toTitleCase(c)); 
       space = false; 
      } 
     } else if (Character.isWhitespace(c)) { 
      space = true; 
     } else { 
      builder.setCharAt(i, Character.toLowerCase(c)); 
     } 
    } 

    return builder.toString(); 
} 

Answer 9

Sólo hacer algo como esto:

public static String toCamelCase(String s){ 
    if(s.length() == 0){ 
     return s; 
    } 
    String[] parts = s.split(" "); 
    String camelCaseString = ""; 
    for (String part : parts){ 
     camelCaseString = camelCaseString + toProperCase(part) + " "; 
    } 
    return camelCaseString; 
} 

public static String toProperCase(String s) { 
    return s.substring(0, 1).toUpperCase() + 
      s.substring(1).toLowerCase(); 
} 

Answer 10

Simplifiqué la respuesta aceptada de @Russ tal que no hay necesidad de diferenciar la primera palabra de la matriz de cadenas del resto de las palabras. (añado el espacio después de cada palabra, a continuación, sólo recortar la frase antes de devolver la frase)

public static String toCamelCaseSentence(String s) { 

    if (s != null) { 
     String[] words = s.split(" "); 

     StringBuilder sb = new StringBuilder(); 

     for (int i = 0; i < words.length; i++) { 
      sb.append(toCamelCaseWord(words[i])); 
     } 

     return sb.toString().trim(); 
    } else { 
     return ""; 
    } 
} 

maneja cadenas vacías (múltiples espacios de oración) y las palabras de una sola letra en la cadena.

public static String toCamelCaseWord(String word) { 
    if (word ==null){ 
     return ""; 
    } 

    switch (word.length()) { 
     case 0: 
      return ""; 
     case 1: 
      return word.toUpperCase(Locale.getDefault()) + " "; 
     default: 
      char firstLetter = Character.toUpperCase(word.charAt(0)); 
      return firstLetter + word.substring(1).toLowerCase(Locale.getDefault()) + " "; 
    } 
} 

Answer 11

Escribí un código basado en el método WordUtils.capitalize() de Apache. Puede establecer sus Delimitadores como una Cadena Regex. Si desea omitir palabras como "de", simplemente configúrelas como un delimitador.

public static String capitalize(String str, final String delimitersRegex) { 
    if (str == null || str.length() == 0) { 
     return ""; 
    } 

    final Pattern delimPattern; 
    if (delimitersRegex == null || delimitersRegex.length() == 0){ 
     delimPattern = Pattern.compile("\\W"); 
    }else { 
     delimPattern = Pattern.compile(delimitersRegex); 
    } 

    final Matcher delimMatcher = delimPattern.matcher(str); 
    boolean delimiterFound = delimMatcher.find(); 

    int delimeterStart = -1; 
    if (delimiterFound){ 
     delimeterStart = delimMatcher.start(); 
    } 

    final int strLen = str.length(); 
    final StringBuilder buffer = new StringBuilder(strLen); 

    boolean capitalizeNext = true; 
    for (int i = 0; i < strLen; i++) { 
     if (delimiterFound && i == delimeterStart) { 
      final int endIndex = delimMatcher.end(); 

      buffer.append(str.substring(i, endIndex)); 
      i = endIndex; 

      if((delimiterFound = delimMatcher.find())){ 
       delimeterStart = delimMatcher.start(); 
      } 

      capitalizeNext = true; 
     } else { 
      final char ch = str.charAt(i); 

      if (capitalizeNext) { 
       buffer.append(Character.toTitleCase(ch)); 
       capitalizeNext = false; 
      } else { 
       buffer.append(ch); 
      } 
     } 
    } 
    return buffer.toString(); 
} 

Espero que ayude :)

Answer 12

Utilice esta función para convertir los datos en caso de camellos

public static String camelCase(String stringToConvert) { 
     if (stringToConvert == null || TextUtils.isEmpty(stringToConvert)) 
      return ""; 
     return Character.toUpperCase(stringToConvert.charAt(0)) + 
       stringToConvert.substring(1).toLowerCase(); 
    }