¿Existe un método para la conversión de cadenas a mayúsculas y minúsculas?

99

¿Hay algún método integrado disponible para convertir una cadena en formato de caso de título?

TylerH
fuente
3
Todos los que lean esta pregunta: tengan en cuenta que muchas de las respuestas más votadas aquí NO FUNCIONAN CORRECTAMENTE para todos los idiomas. Necesita una biblioteca compatible con i18n para el título correcto, como ICU4J (consulte la respuesta de Daniel F).
sffc

Respuestas:

107

Apache Commons StringUtils.capitalize () o Commons Text WordUtils.capitalize ()

por ejemplo: WordUtils.capitalize("i am FINE") = "I Am FINE"de WordUtils doc

aberrante80
fuente
14
WordUtils.capitalizeFully () fue mejor para mí, ya que da: WordUtils.capitalizeFully ("estoy FINE") = "Estoy bien"
theINtoy
2
Solo una pequeña actualización, WordUtils se ha ido a Commons Text y está obsoleto dentro de Commons Lang
msrd0
La primavera también tieneStringUtils.capitalise()
OrangeDog
@OrangeDog quieres decir capitalize()?
TylerH
@TylerH sí, la autocorrección llegó
OrangeDog
60

No hay métodos capitalize () o titleCase () en la clase String de Java. Tienes dos opciones:

 StringUtils.capitalize(null)  = null
 StringUtils.capitalize("")    = ""
 StringUtils.capitalize("cat") = "Cat"
 StringUtils.capitalize("cAt") = "CAt"
 StringUtils.capitalize("'cat'") = "'cat'"
  • escribir (otro) método auxiliar estático enTitleCase ()

Implementación de muestra

public static String toTitleCase(String input) {
    StringBuilder titleCase = new StringBuilder(input.length());
    boolean nextTitleCase = true;

    for (char c : input.toCharArray()) {
        if (Character.isSpaceChar(c)) {
            nextTitleCase = true;
        } else if (nextTitleCase) {
            c = Character.toTitleCase(c);
            nextTitleCase = false;
        }

        titleCase.append(c);
    }

    return titleCase.toString();
}

Caso de prueba

    System.out.println(toTitleCase("string"));
    System.out.println(toTitleCase("another string"));
    System.out.println(toTitleCase("YET ANOTHER STRING"));

salidas:

Cuerda
Otra cuerda
TODAVÍA OTRA CADENA
dfa
fuente
1
Esta es una pequeña rutina agradable, pero falla en el caso más general en el que las cadenas pueden representar nombres. En este caso, las mayúsculas también deberían aparecer después de apóstrofos y guiones. P.ej. O'Connor y J. Wilkes-Booth. Por supuesto, otros idiomas pueden tener reglas de caso de título adicionales.
scottb
... Si fuera a incluir eso, ¿no necesitaría una búsqueda completa en el diccionario solo para averiguar si la palabra actual es un nombre? Eso parece demasiado para cualquier método.
MMJZ
Este código está casi bien porque algunos nombres pueden tener preposiciones como de, del, della, dei, da como en Maria del Carmen, Maria da Silva, Maria della Salute, etc. coderanch.com/t/35096/Programming/…
Junior Mayhé
¿No rompe esto con el apóstrofe? ¿Qué pasa con O'Brian, por ejemplo?
sproketboy
1
Nota: para evitar el cambio de tamaño del utilizado internamente char[]en StringBuilder, sugiero usarnew StringBuilder(input.length())
Lino - Vote no diga gracias
38

Si puedo enviar mi opinión sobre la solución ...

El siguiente método se basa en el que publicó dfa. Realiza el siguiente cambio importante (que se adapta a la solución que necesitaba en ese momento): obliga a todos los caracteres de la cadena de entrada a minúsculas a menos que esté inmediatamente precedido por un "delimitador procesable", en cuyo caso el carácter es forzado a mayúsculas.

Una limitación importante de mi rutina es que asume que el "título de caso" se define uniformemente para todas las configuraciones regionales y está representado por las mismas convenciones de casos que he usado, por lo que es menos útil que el código de dfa en ese sentido.

public static String toDisplayCase(String s) {

    final String ACTIONABLE_DELIMITERS = " '-/"; // these cause the character following
                                                 // to be capitalized
    
    StringBuilder sb = new StringBuilder();
    boolean capNext = true;

    for (char c : s.toCharArray()) {
        c = (capNext)
                ? Character.toUpperCase(c)
                : Character.toLowerCase(c);
        sb.append(c);
        capNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0); // explicit cast not needed
    }
    return sb.toString();
}

VALORES DE PRUEBA

una cuerda

martin o'maLley

john wilkes-booth

TODAVÍA OTRA CADENA

SALIDAS

Una cuerda

Martin O'Malley

John Wilkes-Booth

Sin embargo, otra cuerda

Scottb
fuente
no funcionará con ligaduras como lj, cuya mayúscula es LJ pero el título es Lj. Úselo en su Character.toTitleCaselugar.
mihi
@mihi: tampoco funcionará con otras reglas especializadas, por ejemplo. apellidos como McNamara o MacDonald.
scottb
pero estos casos inherentemente no se pueden arreglar. Se puede usar la función de conversión de mayúsculas y minúsculas correcta (se supone que el título se usa para poner en mayúsculas una palabra, y no en mayúsculas, de acuerdo con las reglas Unicode) se puede hacer (y es fácil).
mihi
¿No haría (no) esto también causar que "ella" se convierta en "ella"?
allicarn
Es verdad. Esto funciona bien en campos de nombre pero, como señala, no en prosa general. Ni siquiera funcionaría bien con todos los nombres, vulcanos en particular (T'Pau en lugar de T'pau).
scottb
20

Utilice WordUtils.capitalizeFully () de Apache Commons.

WordUtils.capitalizeFully(null)        = null
WordUtils.capitalizeFully("")          = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
jiehanzheng
fuente
1
¡Buena solución! ¡Gracias! Pero esto no funciona el 100% del tiempo, ya que también se escribe con mayúscula, por ejemplo, "a" en este título: "Este es un título". Consulte english.stackexchange.com/questions/14/… . ¿Conoce alguna biblioteca que se ocupe de esto?
Eirik W
10

Puede usar apache commons langs como este:

WordUtils.capitalizeFully("this is a text to be capitalize")

puede encontrar el documento de Java aquí: WordUtils.capitalizeFully Java doc

y si desea eliminar los espacios entre los mundos, puede usar:

StringUtils.remove(WordUtils.capitalizeFully("this is a text to be capitalize")," ")

puede encontrar el documento java para String StringUtils.remove java doc

espero que esto ayude.

Vegegoku
fuente
5

Si desea la respuesta correcta de acuerdo con el último estándar Unicode, debe usar icu4j.

UCharacter.toTitleCase(Locale.US, "hello world", null, 0);

Tenga en cuenta que esto es sensible a la configuración regional.

Documentación de API

Implementación

Daniel F
fuente
Vea también el mapa de casos de API ICU4J más reciente: icu-project.org/apiref/icu4j/com/ibm/icu/text/…
sffc
También disponible en el nivel de API de Android 24: developer.android.com/reference/android/icu/lang/…
sffc
3

Aquí hay otra toma basada en las respuestas de @ dfa y @ scottb que maneja cualquier carácter que no sea letra / dígito:

public final class TitleCase {

    public static String toTitleCase(String input) {

        StringBuilder titleCase = new StringBuilder(input.length());
        boolean nextTitleCase = true;

        for (char c : input.toLowerCase().toCharArray()) {
            if (!Character.isLetterOrDigit(c)) {
                nextTitleCase = true;
            } else if (nextTitleCase) {
                c = Character.toTitleCase(c);
                nextTitleCase = false;
            }
            titleCase.append(c);
        }

        return titleCase.toString();
    }

}

Entrada dada:

MARY ÄNN O'CONNEŽ-ŠUSLIK

la salida es

Mary Änn O'Connež-Šuslik

mrts
fuente
2

Esto es algo que escribí para convertir snake_case a lowerCamelCase, pero podría ajustarse fácilmente según los requisitos

private String convertToLowerCamel(String startingText)
{
    String[] parts = startingText.split("_");
    return parts[0].toLowerCase() + Arrays.stream(parts)
                    .skip(1)
                    .map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
                    .collect(Collectors.joining());
}
usuario1743960
fuente
Su respuesta funciona como un encanto, sin embargo, la solución no parece manejar una secuencia de una sola palabra, tal vez una condición if debería ser suficiente.
yashgarg1232
1

Sé que este es más antiguo, pero no tiene una respuesta simple, necesitaba este método para mi codificación, así que agregué aquí, simple de usar.

public static String toTitleCase(String input) {
    input = input.toLowerCase();
    char c =  input.charAt(0);
    String s = new String("" + c);
    String f = s.toUpperCase();
    return f + input.substring(1);
}
Manish Bansal
fuente
1

Tuve este problema y lo busqué, luego hice mi propio método usando algunas palabras clave de Java, solo necesito pasar la variable String como parámetro y obtener la salida como String con el título adecuado.

public class Main
{
  public static void main (String[]args)
  {
    String st = "pARVeEN sISHOsIYA";
    String mainn = getTitleCase (st);
      System.out.println (mainn);
  }


  public static String getTitleCase(String input)
  {
    StringBuilder titleCase = new StringBuilder (input.length());
    boolean hadSpace = false;
    for (char c:input.toCharArray ()){
        if(Character.isSpaceChar(c)){
            hadSpace = true;
            titleCase.append (c);
            continue;
        }
        if(hadSpace){
            hadSpace = false;
            c = Character.toUpperCase(c);
            titleCase.append (c);
        }else{
            c = Character.toLowerCase(c);
            titleCase.append (c);
        }
    }
    String temp=titleCase.toString ();
    StringBuilder titleCase1 = new StringBuilder (temp.length ());
    int num=1;
    for (char c:temp.toCharArray ())
        {   if(num==1)
            c = Character.toUpperCase(c);
            titleCase1.append (c);
            num=0;
        }
        return titleCase1.toString ();
    }
}
Parveen Sishodiya
fuente
Aquí no utilicé el método de recorte en ninguna parte porque en mi caso estaba obteniendo una cuerda recortada adecuada.
Parveen Sishodiya
0

puedes usar muy bien

org.apache.commons.lang.WordUtils

o

CaseFormat

de la API de Google.

gkarthiks
fuente
1
Sería útil agregar el método y un ejemplo.
jechaviz
CaseFormat solo tiene formatos que se usan típicamente en identificadores de programas (UpperCamel, lower-hypen, UPPER_UNDERSCORE, etc.) y solo admite texto ASCII. No funcionaría bien para convertir a caso de título.
M. Justin
0

Recientemente también me encontré con este problema y desafortunadamente tuve muchas apariciones de nombres que comienzan con Mc y Mac, terminé usando una versión del código de scottb que cambié para manejar estos prefijos, por lo que está aquí en caso de que alguien quiera usarlo.

Todavía hay casos extremos que esto pasa por alto, pero lo peor que puede suceder es que una letra sea minúscula cuando debería estar en mayúscula.

/**
 * Get a nicely formatted representation of the name. 
 * Don't send this the whole name at once, instead send it the components.<br>
 * For example: andrew macnamara would be returned as:<br>
 * Andrew Macnamara if processed as a single string<br>
 * Andrew MacNamara if processed as 2 strings.
 * @param name
 * @return correctly formatted name
 */
public static String getNameTitleCase (String name) {
    final String ACTIONABLE_DELIMITERS = " '-/";
    StringBuilder sb = new StringBuilder();
    if (name !=null && !name.isEmpty()){                
        boolean capitaliseNext = true;
        for (char c : name.toCharArray()) {
            c = (capitaliseNext)?Character.toUpperCase(c):Character.toLowerCase(c);
            sb.append(c);
            capitaliseNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0);
        }                       
        name = sb.toString();    
        if (name.startsWith("Mc") && name.length() > 2 ) {
            char c = name.charAt(2);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,2));
                sb.append (name.substring(2,3).toUpperCase());
                sb.append (name.substring(3));
                name=sb.toString();
            }               
        } else if (name.startsWith("Mac") && name.length() > 3) {
            char c = name.charAt(3);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,3));
                sb.append (name.substring(3,4).toUpperCase());
                sb.append (name.substring(4));
                name=sb.toString();
            }
        }
    }
    return name;    
}
El viejo Nick
fuente
0

Conversión a caso de título adecuado:

String s= "ThiS iS SomE Text";
String[] arr = s.split(" ");
s = "";
for (String s1 : arr) {
    s += WordUtils.capitalize(s1.toLowerCase()) + " ";
}
s = s.substring(0, s.length() - 1);

Resultado: "Este es un texto"

VAIBHAV SHEERSH
fuente
0

Usando Spring's StringUtils:

org.springframework.util.StringUtils.capitalize(someText);

Si ya está usando Spring de todos modos, esto evita traer otro marco.

David lavanda
fuente
0

Utilice este método para convertir una cadena en mayúsculas y minúsculas:

static String toTitleCase(String word) {
    return Stream.of(word.split(" "))
            .map(w -> w.toUpperCase().charAt(0)+ w.toLowerCase().substring(1))
            .reduce((s, s2) -> s + " " + s2).orElse("");
}
Abdulhamid Yusuf
fuente
0

Este convertidor transforma cualquier cadena que contenga mayúsculas y minúsculas, espacios en blanco, dígitos y otros caracteres en una caja de título desinfectada.

/**
 * Convert a string to title case in java (with tests).
 *
 * @author Sudipto Chandra
 */
public abstract class TitleCase {

    /**
     * Returns the character type. <br>
     * <br>
     * Digit = 2 <br>
     * Lower case alphabet = 0 <br>
     * Uppercase case alphabet = 1 <br>
     * All else = -1.
     *
     * @param ch
     * @return
     */
    private static int getCharType(char ch) {
        if (Character.isLowerCase(ch)) {
            return 0;
        } else if (Character.isUpperCase(ch)) {
            return 1;
        } else if (Character.isDigit(ch)) {
            return 2;
        }
        return -1;
    }

    /**
     * Converts any given string in camel or snake case to title case.
     * <br>
     * It uses the method getCharType and ignore any character that falls in
     * negative character type category. It separates two alphabets of not-equal
     * cases with a space. It accepts numbers and append it to the currently
     * running group, and puts a space at the end.
     * <br>
     * If the result is empty after the operations, original string is returned.
     *
     * @param text the text to be converted.
     * @return a title cased string
     */
    public static String titleCase(String text) {
        if (text == null || text.length() == 0) {
            return text;
        }

        char[] str = text.toCharArray();
        StringBuilder sb = new StringBuilder();

        boolean capRepeated = false;
        for (int i = 0, prev = -1, next; i < str.length; ++i, prev = next) {
            next = getCharType(str[i]);
            // trace consecutive capital cases
            if (prev == 1 && next == 1) {
                capRepeated = true;
            } else if (next != 0) {
                capRepeated = false;
            }
            // next is ignorable
            if (next == -1) {
                // System.out.printf("case 0, %d %d %s\n", prev, next, sb.toString());
                continue; // does not append anything
            }
            // prev and next are of same type
            if (prev == next) {
                sb.append(str[i]);
                // System.out.printf("case 1, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is not an alphabet
            if (next == 2) {
                sb.append(str[i]);
                // System.out.printf("case 2, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is an alphabet, prev was not +
            // next is uppercase and prev was lowercase
            if (prev == -1 || prev == 2 || prev == 0) {
                if (sb.length() != 0) {
                    sb.append(' ');
                }
                sb.append(Character.toUpperCase(str[i]));
                // System.out.printf("case 3, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is lowercase and prev was uppercase
            if (prev == 1) {
                if (capRepeated) {
                    sb.insert(sb.length() - 1, ' ');
                    capRepeated = false;
                }
                sb.append(str[i]);
                // System.out.printf("case 4, %d %d %s\n", prev, next, sb.toString());
            }
        }
        String output = sb.toString().trim();
        output = (output.length() == 0) ? text : output;
        //return output;

        // Capitalize all words (Optional)
        String[] result = output.split(" ");
        for (int i = 0; i < result.length; ++i) {
            result[i] = result[i].charAt(0) + result[i].substring(1).toLowerCase();
        }
        output = String.join(" ", result);
        return output;
    }

    /**
     * Test method for the titleCase() function.
     */
    public static void testTitleCase() {
        System.out.println("--------------- Title Case Tests --------------------");
        String[][] samples = {
            {null, null},
            {"", ""},
            {"a", "A"},
            {"aa", "Aa"},
            {"aaa", "Aaa"},
            {"aC", "A C"},
            {"AC", "Ac"},
            {"aCa", "A Ca"},
            {"ACa", "A Ca"},
            {"aCamel", "A Camel"},
            {"anCamel", "An Camel"},
            {"CamelCase", "Camel Case"},
            {"camelCase", "Camel Case"},
            {"snake_case", "Snake Case"},
            {"toCamelCaseString", "To Camel Case String"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"ABDTest", "Abd Test"},
            {"title123Case", "Title123 Case"},
            {"expect11", "Expect11"},
            {"all0verMe3", "All0 Ver Me3"},
            {"___", "___"},
            {"__a__", "A"},
            {"_A_b_c____aa", "A B C Aa"},
            {"_get$It132done", "Get It132 Done"},
            {"_122_", "122"},
            {"_no112", "No112"},
            {"Case-13title", "Case13 Title"},
            {"-no-allow-", "No Allow"},
            {"_paren-_-allow--not!", "Paren Allow Not"},
            {"Other.Allow.--False?", "Other Allow False"},
            {"$39$ldl%LK3$lk_389$klnsl-32489  3 42034 ", "39 Ldl Lk3 Lk389 Klnsl32489342034"},
            {"tHis will BE MY EXAMple", "T His Will Be My Exa Mple"},
            {"stripEvery.damn-paren- -_now", "Strip Every Damn Paren Now"},
            {"getMe", "Get Me"},
            {"whatSthePoint", "What Sthe Point"},
            {"n0pe_aLoud", "N0 Pe A Loud"},
            {"canHave SpacesThere", "Can Have Spaces There"},
            {"  why_underScore exists  ", "Why Under Score Exists"},
            {"small-to-be-seen", "Small To Be Seen"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"last one onTheList", "Last One On The List"}
        };
        int pass = 0;
        for (String[] inp : samples) {
            String out = titleCase(inp[0]);
            //String out = WordUtils.capitalizeFully(inp[0]);
            System.out.printf("TEST '%s'\nWANTS '%s'\nFOUND '%s'\n", inp[0], inp[1], out);
            boolean passed = (out == null ? inp[1] == null : out.equals(inp[1]));
            pass += passed ? 1 : 0;
            System.out.println(passed ? "-- PASS --" : "!! FAIL !!");
            System.out.println();
        }
        System.out.printf("\n%d Passed, %d Failed.\n", pass, samples.length - pass);
    }

    public static void main(String[] args) {
        // run tests
        testTitleCase();
    }
}

Aquí hay algunas entradas:

aCamel
TitleCase
snake_case
fromCamelCASEString
ABCTest
expect11
_paren-_-allow--not!
  why_underScore   exists  
last one onTheList 

Y mis salidas:

A Camel
Title Case
Snake Case
From Camel Case String
Abc Test
Expect11
Paren Allow Not
Why Under Score Exists
Last One On The List
Dipu
fuente
0

Parece que ninguna de las respuestas lo formatea en el caso del título real: "Cómo conseguir el trabajo de tus sueños", "Matar un ruiseñor", etc., así que he creado mi propio método. Funciona mejor para textos en inglés.

private final static Set<Character> TITLE_CASE_DELIMITERS = new HashSet<>();

  static {
    TITLE_CASE_DELIMITERS.add(' ');
    TITLE_CASE_DELIMITERS.add('.');
    TITLE_CASE_DELIMITERS.add(',');
    TITLE_CASE_DELIMITERS.add(';');
    TITLE_CASE_DELIMITERS.add('/');
    TITLE_CASE_DELIMITERS.add('-');
    TITLE_CASE_DELIMITERS.add('(');
    TITLE_CASE_DELIMITERS.add(')');
  }

  private final static Set<String> TITLE_SMALLCASED_WORDS = new HashSet<>();

  static {
    TITLE_SMALLCASED_WORDS.add("a");
    TITLE_SMALLCASED_WORDS.add("an");
    TITLE_SMALLCASED_WORDS.add("the");
    TITLE_SMALLCASED_WORDS.add("for");
    TITLE_SMALLCASED_WORDS.add("in");
    TITLE_SMALLCASED_WORDS.add("on");
    TITLE_SMALLCASED_WORDS.add("of");
    TITLE_SMALLCASED_WORDS.add("and");
    TITLE_SMALLCASED_WORDS.add("but");
    TITLE_SMALLCASED_WORDS.add("or");
    TITLE_SMALLCASED_WORDS.add("nor");
    TITLE_SMALLCASED_WORDS.add("to");
  }

  public static String toCapitalizedWord(String oneWord) {
    if (oneWord.length() < 1) {
      return oneWord.toUpperCase();
    }
    return "" + Character.toTitleCase(oneWord.charAt(0)) + oneWord.substring(1).toLowerCase();
  }

  public static String toTitledWord(String oneWord) {
    if (TITLE_SMALLCASED_WORDS.contains(oneWord.toLowerCase())) {
      return oneWord.toLowerCase();
    }
    return toCapitalizedWord(oneWord);
  }

  public static String toTitleCase(String str) {
    StringBuilder result = new StringBuilder();
    StringBuilder oneWord = new StringBuilder();

    char previousDelimiter = 'x';
    /* on start, always move to upper case */
    for (char c : str.toCharArray()) {
      if (TITLE_CASE_DELIMITERS.contains(c)) {
        if (previousDelimiter == '-' || previousDelimiter == 'x') {
          result.append(toCapitalizedWord(oneWord.toString()));
        } else {
          result.append(toTitledWord(oneWord.toString()));
        }
        oneWord.setLength(0);
        result.append(c);
        previousDelimiter = c;
      } else {
        oneWord.append(c);
      }
    }
    if (previousDelimiter == '-' || previousDelimiter == 'x') {
      result.append(toCapitalizedWord(oneWord.toString()));
    } else {
      result.append(toTitledWord(oneWord.toString()));
    }
    return result.toString();
  }

  public static void main(String[] args) {
    System.out.println(toTitleCase("one year in paris"));
    System.out.println(toTitleCase("How to Land Your Dream Job"));
  }
Mladen Adamovic
fuente
0

Esta es la solucion mas simple

    static void title(String a,String b){
    String ra = Character.toString(Character.toUpperCase(a.charAt(0)));
    String rb = Character.toString(Character.toUpperCase(b.charAt(0)));
    for(int i=1;i<a.length();i++){
        ra+=a.charAt(i);
    }
    for(int i=1;i<b.length();i++){
        rb+=b.charAt(i);
    }
    System.out.println(ra+" "+rb);
Reppin Frost
fuente
-1

Esto debería funcionar:

String str="i like pancakes";
String arr[]=str.split(" ");
String strNew="";
for(String str1:arr)
{
    Character oldchar=str1.charAt(0);
    Character newchar=Character.toUpperCase(str1.charAt(0));
    strNew=strNew+str1.replace(oldchar,newchar)+" ";    
}
System.out.println(strNew);
Neha
fuente
1
Esta no es una respuesta válida ya que el OP solicitó una función incorporada . Consulte también el comentario que aborda la complejidad oculta detrás de esto, es decir, i18n.
Marcus
-2

La forma más sencilla de convertir cualquier cadena en un caso de título es utilizar el paquete de googles org.apache.commons.lang.WordUtils

System.out.println(WordUtils.capitalizeFully("tHis will BE MY EXAMple"));

Resultará esto

Este será mi ejemplo

No estoy seguro de por qué se llama "capitalizeFully", donde de hecho la función no está haciendo un resultado de capital completo, pero de todos modos, esa es la herramienta que necesitamos.

JoeG
fuente
1
Se nombra capitalizeFullyporque escribe en mayúscula cada palabra, incluidas las que deben estar en minúscula en un título. grammar.about.com/od/tz/g/Title-Case.htm
aij
2
Apache Commons no es propiedad de Google. Es mantenido por la Apache Software Foundation. commons.apache.org
ATutorMe
-3

Lo siento, soy un principiante, ¡así que mi hábito de codificación apesta!

public class TitleCase {

    String title(String sent)
    {   
        sent =sent.trim();
        sent = sent.toLowerCase();
        String[] str1=new String[sent.length()];
        for(int k=0;k<=str1.length-1;k++){
            str1[k]=sent.charAt(k)+"";
    }

        for(int i=0;i<=sent.length()-1;i++){
            if(i==0){
                String s= sent.charAt(i)+"";
                str1[i]=s.toUpperCase();
                }
            if(str1[i].equals(" ")){
                String s= sent.charAt(i+1)+"";
                str1[i+1]=s.toUpperCase();
                }

            System.out.print(str1[i]);
            }

        return "";
        }

    public static void main(String[] args) {
        TitleCase a = new TitleCase();
        System.out.println(a.title("   enter your Statement!"));
    }
}
Vishwanath Dasa
fuente