programacion - manual de android en pdf

¿Cómo convierto una cadena a un caso de título en Android?

Question

Busqué alto y bajo, pero solo pude encontrar referencias indirectas a este tipo de pregunta. Al desarrollar una aplicación de Android, si tiene una cadena que ha sido ingresada por el usuario, ¿cómo puede convertirla en un caso de título (es decir, hacer la primera letra de cada palabra en mayúsculas)? Preferiría no importar una biblioteca completa (como WordUtils de Apache).

Answer 1

Acabo de tener el mismo problema y lo resolví 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 que, en mi caso, también tenía que eliminar los puntos. Cualquier carácter que deba ser reemplazado por espacios puede insertarse entre los tirantes cuadrados durante la "división". Por ejemplo, lo siguiente finalmente reemplazaría los guiones bajos, puntos, comas o espacios en blanco:

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

Esto, por supuesto, se puede lograr mucho más simplemente con el símbolo de "carácter sin palabra" :

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

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

Answer 2

Aquí está el método WordUtils.capitalize () en caso de que no quiera 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 eso ayude.

Answer 3

En el XML, puedes hacerlo así:

android:inputType="textCapWords"

Verifique la referencia para otras opciones, como Caso de oraciones, todas las letras superiores, etc. aquí:

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

Answer 4

Escribí un código basado en el método WordUtils.capitalize () de Apache. Puede configurar 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 5

Estás buscando el método WordUtils.capitalize() Apache.

Answer 6

Ponga 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 7

Por favor, compruebe la solución a continuación que funcionará tanto para cadenas múltiples como para cadenas simples

 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

Recibí algunos consejos desde aquí: Android, debo hacer en mi ListView la primera letra de cada palabra en mayúscula , pero al final, presenté mi propia solución (tenga en cuenta que 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 EditarTexto. También es útil establecer el tipo de entrada en la vista para que, de todos modos, se establezca de forma predeterminada el caso de título:

input.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS);

Answer 9

Simplifiqué la respuesta aceptada de @Russ, de modo que no es necesario diferenciar la primera palabra de la cadena de cadenas del resto de las palabras. (Agrego el espacio después de cada palabra, luego recorte la oración antes de devolverla)

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 (espacios múltiples en oraciones) y 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 10

Solo haz 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 11

Utilice esta función para convertir datos en camel case

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

Answer 12

esto te ayuda

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