Conversión de cadena a mayúscula

¿Hay algún método integrado disponible para convertir una cadena en formato de Título de Caso como tal?

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

Ejemplo: WordUtils.capitalize("i am FINE") = "I Am FINE" BIEN WordUtils.capitalize("i am FINE") = "I Am FINE" del documento de WordUtils

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

  • usando commons lang string utils .
  StringUtils.capitalize(null) = null StringUtils.capitalize("") = "" StringUtils.capitalize("cat") = "Cat" StringUtils.capitalize("cAt") = "CAt" StringUtils.capitalize("'cat'") = "'cat'" 
  • escribir (otro más) método de ayuda estático toTitleCase ()

Implementación de muestra

 public static String toTitleCase(String input) { StringBuilder titleCase = new StringBuilder(); 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")); 

productos:

 Cuerda
 Otra cadena
 AÚN OTRA CADENA

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

El siguiente método se basa en el que dfa publicó. Hace el siguiente cambio principal (que se adapta a la solución que necesitaba en ese momento): fuerza a todos los caracteres de la cadena de entrada a minúsculas a menos que esté precedido inmediatamente por un “delimitador accionable” en cuyo caso el personaje es forzado a mayúscula

Una limitación importante de mi rutina es suponer que el “caso del título” está uniformemente definido 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 al respecto.

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

AÚN OTRA CADENA

SALIDAS

Una cuerda

Martin O’Malley

John Wilkes-Booth

Sin embargo, otra cadena

Use WordUtils.capitalizeFully () de Apache Commons.

 WordUtils.capitalizeFully(null) = null WordUtils.capitalizeFully("") = "" WordUtils.capitalizeFully("i am FINE") = "I Am Fine" 

Puede usar lenguajes de Apache commons como este:

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

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

y si quieres eliminar los espacios entre los mundos, puedes usar:

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

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

espero esta ayuda

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 Api

Implementación

Esto es algo que escribí para convertir snake_case en lowerCamelCase, pero podría ajustarse fácilmente en función de 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()); } 

Sé que este es más antiguo, pero no tiene la respuesta simple, necesitaba este método para mi encoding, así que agregué aquí, fácil 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); } 

puedes usar muy bien

org.apache.commons.lang.WordUtils

o

CaseFormat

de la API de Google.

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

 public final class TitleCase { public static String toTitleCase(String input) { StringBuilder titleCase = new StringBuilder(); 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

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

Todavía hay casos límite que se pierde, pero lo peor que puede pasar es que una letra será minúscula cuando se debe escribir 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.
* For example: andrew macnamara would be returned as:
* Andrew Macnamara if processed as a single string
* 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; }

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: “This Is Some Text”

Necesitaba un convertidor de mayúsculas y minúsculas para transformar cualquier cadena que contuviera camel case, espacios en blanco, dígitos y otros caracteres. Pero ninguna de las soluciones disponibles funcionó. Al final, construí uno para mí.

 /* * Copyright (C) 2018 Sudipto Chandra * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ /** * Convert a string to title case in java (with tests). * * @author Sudipto Chandra */ public abstract class TitleCase { /** * Returns the character type. 
*
* Digit = 2
* Lower case alphabet = 0
* Uppercase case alphabet = 1
* 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. *
* 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. *
* 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", "AC"}, {"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", "ABC 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 resultados:

 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 

¡Lo siento, soy un principiante, así que mi hábito de encoding es una mierda!

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

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

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

Conseguirá esto

Este será mi ejemplo

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