Comment convertir une chaîne en titre sous Android?
J'ai cherché haut et bas mais n'ai pu trouver que des références indirectes à ce type de question. Lors du développement d'une application Android, si vous avez une chaîne entrée par l'utilisateur, comment pouvez-vous la convertir en casse de titre (c'est-à-dire créer la première lettre de chaque mot majuscule)? Je préférerais ne pas importer une bibliothèque entière (telle que WordUtils d'Apache).
Mettez ceci dans votre classe d'utilitaires de texte:
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();
}
J’ai eu quelques indications d’ici: Android, il faut que ma liste affiche la première lettre de chaque mot majuscule , mais au final, j’ai ma propre solution (notez que cette approche suppose que tous les mots sont séparés par un seul mot). caractère de l'espace, ce qui était bien pour mes besoins):
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();
... où l'entrée est une vue EditText. Il est également utile de définir le type d'entrée sur la vue de sorte que le titre soit par défaut le cas de titre:
input.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS);
cela vous aide
EditText view = (EditText) find..
String txt = view.getText();
txt = String.valueOf(txt.charAt(0)).toUpperCase() + txt.substring(1, txt.length());
Vous recherchez la méthode WordUtils.capitalize() de Apache .
Dans le XML, vous pouvez le faire comme ceci:
Android:inputType="textCapWords"
Vérifiez la référence pour d'autres options, telles que la casse de phrase, toutes les lettres majuscules, etc. ici:
http://developer.Android.com/reference/Android/widget/TextView.html#attr_Android:inputType
Voici la méthode WordUtils.capitalize () au cas où vous ne voudriez pas importer la classe entière.
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;
}
J'espère que ça aide.
Faites juste quelque chose comme ça:
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();
}
Je viens d'avoir le même problème et résolu avec ceci:
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);
Notez que dans mon cas, je devais également supprimer les règles. Tous les caractères devant être remplacés par des espaces peuvent être insérés entre les accolades lors de la "scission". Par exemple, les éléments suivants remplaceraient en fin de compte les caractères de soulignement, les points, les virgules ou les espaces:
String[] words = input.split("[_.,\\s]+");
Ceci, bien sûr, peut être accompli beaucoup plus simplement avec le symbole "caractère non-Word" :
String[] words = input.split("\\W+");
Il vaut la peine de mentionner que les chiffres et les tiretsSONTconsidérés comme des "caractères Word". Cette dernière version répondait parfaitement à mes besoins et, espérons-le, aiderait quelqu'un d'autre.
Veuillez vérifier la solution ci-dessous, cela fonctionnera aussi bien pour plusieurs chaînes que pour une seule chaîne.
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());
}
Utilisez cette fonction pour convertir des données en camel case
public static String camelCase(String stringToConvert) {
if (TextUtils.isEmpty(stringToConvert))
{return "";}
return Character.toUpperCase(stringToConvert.charAt(0)) +
stringToConvert.substring(1).toLowerCase();
}
J'ai simplifié la réponse acceptée de @Russ en évitant de différencier le premier mot du tableau de chaînes du reste des mots. (J'ajoute l'espace après chaque mot, puis coupe la phrase avant renvoyer la phrase)
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 "";
}
}
gère les chaînes vides (plusieurs espaces dans la phrase) et les mots d'une seule lettre dans la chaîne.
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()) + " ";
}
}
Kotlin - Android - Title Case/Fonction Camel Case
fun toTitleCase(str: String?): String? {
if (str == null) {
return null
}
var space = true
val builder = StringBuilder(str)
val len = builder.length
for (i in 0 until len) {
val c = builder[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()
}
OU
fun camelCase(stringToConvert: String): String {
if (TextUtils.isEmpty(stringToConvert)) {
return "";
}
return Character.toUpperCase(stringToConvert[0]) +
stringToConvert.substring(1).toLowerCase();
}
J'ai écrit un code basé sur la méthode WordUtils.capitalize () d'Apache. Vous pouvez définir vos délimiteurs en tant que chaîne de regex. Si vous souhaitez ignorer des mots tels que "de", définissez-les simplement comme un séparateur.
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();
}
J'espère que cela pourra aider :)