Using regular expressions would give you a bit more flexibility. Here's an example:
public class WordUpperCaseExample {
public static final Locale pt_BR = new Locale("pt","BR");
public static void main(String[] args) {
String[] examples = { "douglas léonardo.smc", "XGR - STS.SMC", "xpto.smc", "aRqUiVo_cOmPoStO.tXt", "aRqUiVo-cOmPoStO.tXt", "123nome.txt" };
for (String e : examples) {
System.out.println(upperCaseWords(e));
}
}
public static String upperCaseWords(String phrase) {
Matcher m = Pattern.compile("\.?[\p{IsAlphabetic}][\w\d&&[^_]]*", Pattern.UNICODE_CHARACTER_CLASS).matcher(phrase);
StringBuffer sb = new StringBuffer();
while (m.find()) m.appendReplacement(sb, upperCaseFirst(m.group()));
return m.appendTail(sb).toString();
}
public static String upperCaseFirst(String word) {
return word.isEmpty() ? word :
word.length() == 1 ? word.toUpperCase(pt_BR) :
word.startsWith(".") ? word.toLowerCase(pt_BR) : (word.substring(0, 1).toUpperCase(pt_BR) + word.substring(1).toLowerCase(pt_BR));
}
}
The regular expression \.?[\p{IsAlphabetic}][\w\d&&[^_]]* may seem complex, but it looks for words that:
\.? : optionally start with a dot, which would be the file extension. So I check if the captured group starts with a dot, and if true, it converts everything to lowercase.
[\p{IsAlphabetic}] : The force that the first character of the group captured by the expression is an alphabetic character in the Unicode table. This causes, for example, 123nome to 123Nome , since the expression will capture just beginning from the first letter. This restriction also causes other characters dividing words not to be captured.
[\w\d&&[^_]]* causes other letters and numbers to be captured while &&[^_] ignores underscore . This causes abc_abc to Abc_Abc .
In addition, the parameter Pattern.UNICODE_CHARACTER_CLASS causes characters in the Unicode table to be considered, so, for example, \w will capture accented characters like á in addition to those belonging to the ASCII pattern as a .
The upperCaseFirst method converts each word. It contains any additional logic needed to convert a captured word. The rules of the above example are:
Empty word, it does nothing. This is only for precaution, since the regular expression does not allow this to occur. Thus the method can be reused with security and efficiency.
Word with a character, converts to upper case. However you may want to change this so that olhe a casa Olhe a Casa and not Olhe A Casa as it is now.
If the word begins with a period, it converts to lowercase. This is to handle the file extension case, but it can cause side effects if there are other points in the file name. If you want to handle this, it is better to treat the extension separately as in the reply in Rodrigo.
In all other cases, convert the first character to upper case and the rest to lowercase. Note that I always specify the locale to perform the conversion operations. This avoids possible inconsistencies if the program runs in different environments where the Java language is different.
The general idea of the implementation is that you can easily add and modify the rules by changing the regular expression as Documentation of class Pattern allows and also the upperCaseFirst method.
