String str = "java";
String cap = str.substring(0, 1).toUpperCase() + str.substring(1);
// cap = "Java"

用你的例子:

public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// Actually use the Reader
String name = br.readLine();
// Don't mistake String object with a Character object
String s1 = name.substring(0, 1).toUpperCase();
String nameCapitalized = s1 + name.substring(1);
System.out.println(nameCapitalized);
}

StringUtils.capitalize(..)从commons lang

WordUtils.capitalize(java.lang.String)从Apache Commons。

使用WordUtils.capitalize(str)。

你要做的可能是:

s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

(将第一个字符转换为大写，并添加原始字符串的其余部分)

此外，您创建了一个输入流读取器，但从不读取任何行。因此name将始终是null。

这应该可以工作:

BufferedReader br = new InputstreamReader(System.in);
String name = br.readLine();
String s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

你也可以试试这个:

 String s1 = br.readLine();
char[] chars = s1.toCharArray();
chars[0] = Character.toUpperCase(chars[0]);
s1= new String(chars);
System.out.println(s1);

这比使用substring更好(优化了)。(但不用担心小弦)

这只是为了告诉你，你没有错。

BufferedReader br = new InputstreamReader(System.in);
// Assuming name is not blank
String name = br.readLine();


//No more error telling that you cant convert char to string
String s1 = (""+name.charAt(0)).toUppercase());
// Or, as Carlos prefers. See the comments to this post.
String s1 = Character.toString(name.charAt(0)).toUppercase());


System.out.println(s1+name.substring(1));

注意: 这根本不是最好的方法。这只是为了告诉OP，它也可以使用charAt()来完成。；）

你可以使用substring()来做到这一点。

但有两种情况:

案例1

如果你要大写的String是为了便于人类阅读，你还应该指定默认的语言环境:

String firstLetterCapitalized =
myString.substring(0, 1).toUpperCase(Locale.getDefault()) + myString.substring(1);

案例2

如果你要大写的String是机器可读的，避免使用Locale.getDefault()，因为返回的字符串在不同的地区会不一致，在这种情况下总是指定相同的地区(例如，toUpperCase(Locale.ENGLISH))。这将确保用于内部处理的字符串是一致的，这将帮助您避免难以发现的错误。

注意:你不必为toLowerCase()指定Locale.getDefault()，因为这是自动完成的。

字符串首字母大写的更短/更快的版本代码是:

String name  = "stackoverflow";
name = name.substring(0,1).toUpperCase() + name.substring(1).toLowerCase();

name的值是"Stackoverflow"

试试这个

这个方法做的是，考虑单词“hello world”这个方法把它变成“hello world”每个单词的开头大写。

 private String capitalizer(String word){


String[] words = word.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());
}
}
return  sb.toString();


}

这是可行的

char[] array = value.toCharArray();


array[0] = Character.toUpperCase(array[0]);


String result = new String(array);

在Android Studio中

将这个依赖项添加到你的build.gradle (Module: app)

dependencies {
...
compile 'org.apache.commons:commons-lang3:3.1'
...
}

现在你可以使用

String string = "STRING WITH ALL CAPPS AND SPACES";


string = string.toLowerCase(); // Make all lowercase if you have caps


someTextView.setText(WordUtils.capitalize(string));

下面的例子也将特殊字符后的单词大写，如[/-]

  public static String capitalize(String text) {
char[] stringArray = text.trim().toCharArray();
boolean wordStarted = false;
for( int i = 0; i < stringArray.length; i++) {
char ch = stringArray[i];
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '\'') {
if( !wordStarted ) {
stringArray[i] = Character.toUpperCase(stringArray[i]);
wordStarted = true;
}
} else {
wordStarted = false;
}
}
return new String(stringArray);
}


Example:
capitalize("that's a beautiful/wonderful life we have.We really-do")


Output:
That's A Beautiful/Wonderful Life We Have.We Really-Do

谢谢，我已经阅读了一些评论，并带来了以下内容

public static void main(String args[])
{
String myName = "nasser";
String newName = myName.toUpperCase().charAt(0) +  myName.substring(1);
System.out.println(newName );
}

看一下ACL WordUtils。

WordUtils。大写("your string") == "your string"

如何大写单词的第一个字母在一个字符串?< / >

您可以使用以下代码:

public static void main(String[] args) {


capitalizeFirstLetter("java");
capitalizeFirstLetter("java developer");
}


public static void capitalizeFirstLetter(String text) {


StringBuilder str = new StringBuilder();


String[] tokens = text.split("\\s");// Can be space,comma or hyphen


for (String token : tokens) {
str.append(Character.toUpperCase(token.charAt(0))).append(token.substring(1)).append(" ");
}
str.toString().trim(); // Trim trailing space


System.out.println(str);


}

来自Ameen Mahheen的答案很好，但如果我们有一些双空格字符串，如“hello world”，那么sb.append得到IndexOutOfBounds异常。正确的做法是在这行之前测试，做:

private String capitalizer(String word){
String[] words = word.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(" ");
if (words[i].length() > 0) sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
}
}
return  sb.toString();
}

试试这个，对我很管用。

public static String capitalizeName(String name) {
String fullName = "";
String names[] = name.split(" ");
for (String n: names) {
fullName = fullName + n.substring(0, 1).toUpperCase() + n.toLowerCase().substring(1, n.length()) + " ";
}
return fullName;
}

很多答案都非常有用，所以我用它们创建了一个方法来将任何字符串转换为标题(第一个字符大写):

static String toTitle (String s) {
String s1 = s.substring(0,1).toUpperCase();
String sTitle = s1 + s.substring(1);
return sTitle;
}

将字符串设置为小写，然后将第一个字母设置为大写，如下所示:

    userName = userName.toLowerCase();

然后把第一个字母大写:

    userName = userName.substring(0, 1).toUpperCase() + userName.substring(1).toLowerCase();

Substring只是得到一个更大的字符串的一部分，然后我们将它们组合在一起。

你可以试试这个

/**
* capitilizeFirst(null)  -> ""
* capitilizeFirst("")    -> ""
* capitilizeFirst("   ") -> ""
* capitilizeFirst(" df") -> "Df"
* capitilizeFirst("AS")  -> "As"
*
* @param str input string
* @return String with the first letter capitalized
*/
public String capitilizeFirst(String str)
{
// assumptions that input parameter is not null is legal, as we use this function in map chain
Function<String, String> capFirst = (String s) -> {
String result = ""; // <-- accumulator


try { result += s.substring(0, 1).toUpperCase(); }
catch (Throwable e) {}
try { result += s.substring(1).toLowerCase(); }
catch (Throwable e) {}


return result;
};


return Optional.ofNullable(str)
.map(String::trim)
.map(capFirst)
.orElse("");
}

你可以使用类WordUtils。

假设你的字符串是“当前地址”，然后使用

* * * *强大的文本<强> Wordutils.capitaliz(字符串); output: Current Address

参考:http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/text/WordUtils.html

class CapitalizeWords
{
public static void main(String[] args)
{
String input ="welcome to kashmiri geeks...";


System.out.println(input);


String[] str = input.split(" ");


for(int i=0; i< str.length; i++)
{
str[i] = (str[i]).substring(0,1).toUpperCase() + (str[i]).substring(1);
}


for(int i=0;i<str.length;i++)
{
System.out.print(str[i]+" ");
}




}
}

public static String capitalizer(final String texto) {


// split words
String[] palavras = texto.split(" ");
StringBuilder sb = new StringBuilder();


// list of word exceptions
List<String> excessoes = new ArrayList<String>(Arrays.asList("de", "da", "das", "do", "dos", "na", "nas", "no", "nos", "a", "e", "o", "em", "com"));


for (String palavra : palavras) {


if (excessoes.contains(palavra.toLowerCase()))
sb.append(palavra.toLowerCase()).append(" ");
else
sb.append(Character.toUpperCase(palavra.charAt(0))).append(palavra.substring(1).toLowerCase()).append(" ");
}
return sb.toString().trim();
}

您可以使用以下代码:

public static String capitalizeString(String string) {


if (string == null || string.trim().isEmpty()) {
return string;
}
char c[] = string.trim().toLowerCase().toCharArray();
c[0] = Character.toUpperCase(c[0]);


return new String(c);


}

使用JUnit的示例测试:

@Test
public void capitalizeStringUpperCaseTest() {


String string = "HELLO WORLD  ";


string = capitalizeString(string);


assertThat(string, is("Hello world"));
}


@Test
public void capitalizeStringLowerCaseTest() {


String string = "hello world  ";


string = capitalizeString(string);


assertThat(string, is("Hello world"));
}

你可以使用子字符串进行简单的hack;)。

String name;
    

String s1 = name.substring(0, 1).toUpperCase() + name.substring(1, name.length());


System.out.println(s1));

那WordUtils.capitalizeFully ()呢?

import org.apache.commons.lang3.text.WordUtils;


public class Main {


public static void main(String[] args) {


final String str1 = "HELLO WORLD";
System.out.println(capitalizeFirstLetter(str1)); // output: Hello World


final String str2 = "Hello WORLD";
System.out.println(capitalizeFirstLetter(str2)); // output: Hello World


final String str3 = "hello world";
System.out.println(capitalizeFirstLetter(str3)); // output: Hello World


final String str4 = "heLLo wORld";
System.out.println(capitalizeFirstLetter(str4)); // output: Hello World
}


private static String capitalizeFirstLetter(String str) {
return WordUtils.capitalizeFully(str);
}
}

最短的:

String message = "my message";
message = Character.toUpperCase(message.charAt(0)) + message.substring(1);
System.out.println(message)    // Will output: My message

为我工作。

String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);

那些谁搜索首字母大写的名字在这里..

public static String capitaliseName(String name) {
String collect[] = name.split(" ");
String returnName = "";
for (int i = 0; i < collect.length; i++) {
collect[i] = collect[i].trim().toLowerCase();
if (collect[i].isEmpty() == false) {
returnName = returnName + collect[i].substring(0, 1).toUpperCase() + collect[i].substring(1) + " ";
}
}
return returnName.trim();
}

usase: capitaliseName(“saurav汗”);

输出: Saurav汗

刚刚重做了Jorgesys代码和增加了一些检查，因为很少有与字符串长度相关的情况。不要做空参考检查在我的情况下。

 public static String capitalizeFirstLetter(@NonNull String customText){
int count = customText.length();
if (count == 0) {
return customText;
}
if (count == 1) {
return customText.toUpperCase();
}
return customText.substring(0, 1).toUpperCase() + customText.substring(1).toLowerCase();
}

System.out.println(Character.toString(A.charAt(0)).toUpperCase()+A.substring(1));

P.S = a是一个字符串。

使用Apache的公共库。把你的大脑从这些东西中解放出来，避免空指针索引脱离绑定异常

步骤1:

通过在build.gradle dependencies中导入apache的common lang库

implementation 'org.apache.commons:commons-lang3:3.6'

步骤2:

如果你确定你的字符串都是小写的，或者你只需要初始化第一个字母，直接调用

StringUtils.capitalize(yourString);

如果你想确保只有第一个字母是大写的，就像对enum这样做，首先调用toLowerCase()，并记住，如果输入字符串为空，它将抛出NullPointerException。

StringUtils.capitalize(YourEnum.STUFF.name().toLowerCase());
StringUtils.capitalize(yourString.toLowerCase());

以下是apache提供的更多示例。它是无异常的

StringUtils.capitalize(null)  = null
StringUtils.capitalize("")    = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
StringUtils.capitalize("'cat'") = "'cat'"

注意:

WordUtils也包含在这个库中，但已弃用。请使用它。

下面的解决方案将工作。

String A = "stackOverflow";
String ACaps = A.toUpperCase().charAt(0)+A.substring(1,A.length());
//Will print StackOverflow

你不能在原始字符上使用toUpperCase()，但你可以先将整个String变成大写，然后取第一个字符，然后像上面所示的那样追加到子字符串。

使用commons.lang.StringUtils，最好的答案是:

public static String capitalize(String str) {
int strLen;
return str != null && (strLen = str.length()) != 0 ? (new StringBuffer(strLen)).append(Character.toTitleCase(str.charAt(0))).append(str.substring(1)).toString() : str;
}

我发现它很聪明，因为它用StringBuffer包装字符串。您可以随心所欲地操作StringBuffer，尽管使用相同的实例。

String s = "first second third fourth";


int j = 0;
for (int i = 0; i < s.length(); i++) {


if ((s.substring(j, i).endsWith(" "))) {


String s2 = s.substring(j, i);
System.out.println(Character.toUpperCase(s.charAt(j))+s2.substring(1));
j = i;
}
}
System.out.println(Character.toUpperCase(s.charAt(j))+s.substring(j+1));

要将字符串中每个单词的第一个字符大写，

首先你需要获取字符串的每个单词&对于这个分割字符串，其中任何空间都使用split方法，如下所示，并将每个单词存储在数组中。 然后创建一个空字符串。之后使用substring()方法获取第一个字符&对应单词的剩余字符，并存储在两个不同的变量中

然后使用toUpperCase()方法将第一个字符大写，并将如下所示的其余字符添加到空字符串中。

public class Test {
public static void main(String[] args)
{
String str= "my name is khan";        // string
String words[]=str.split("\\s");      // split each words of above string
String capitalizedWord = "";         // create an empty string


for(String w:words)
{
String first = w.substring(0,1);    // get first character of each word
String f_after = w.substring(1);    // get remaining character of corresponding word
capitalizedWord += first.toUpperCase() + f_after+ " ";  // capitalize first character and add the remaining to the empty string and continue
}
System.out.println(capitalizedWord);    // print the result
}
}

使用此实用程序方法将每个单词的第一个字母大写。

String capitalizeAllFirstLetters(String name)
{
char[] array = name.toCharArray();
array[0] = Character.toUpperCase(array[0]);
 

for (int i = 1; i < array.length; i++) {
if (Character.isWhitespace(array[i - 1])) {
array[i] = Character.toUpperCase(array[i]);
}
}
 

return new String(array);
}

我发布的代码将从字符串中删除下划线(_)符号和额外的空格，而且它将大写字符串中每个新词的第一个字母

private String capitalize(String txt){
List<String> finalTxt=new ArrayList<>();


if(txt.contains("_")){
txt=txt.replace("_"," ");
}


if(txt.contains(" ") && txt.length()>1){
String[] tSS=txt.split(" ");
for(String tSSV:tSS){ finalTxt.add(capitalize(tSSV)); }
}


if(finalTxt.size()>0){
txt="";
for(String s:finalTxt){ txt+=s+" "; }
}


if(txt.endsWith(" ") && txt.length()>1){
txt=txt.substring(0, (txt.length()-1));
return txt;
}


txt = txt.substring(0,1).toUpperCase() + txt.substring(1).toLowerCase();
return txt;
}

一种方法。

String input = "someТекст$T%$4čřЭ"; //Enter your text.
if (input == null || input.isEmpty()) {
return "";
}


char [] chars = input.toCharArray();
chars[0] = chars[0].toUpperCase();
String res = new String(chars);
return res;

此方法的缺点是，如果inputString很长，则将有三个这样长度的对象。和你一样

String s1 = input.substring(1).toUpperCase();
String s2 = input.substring(1, lenght);
String res = s1 + s2;

甚至

//check if not null.
StringBuilder buf = new StringBuilder(input);
char ch = buf.getCharAt(0).toUpperCase();
buf.setCharAt(0, ch);
return buf.toString();

再举一个例子，如何让用户输入的第一个字母大写:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String string = br.readLine();
// handle supplementary characters
IntStream.concat(
IntStream.of(string.codePointAt(0))
.map(Character::toUpperCase), string.codePoints().skip(1)
)
.forEach(cp -> System.out.print(Character.toChars(cp)));

这段代码在文本中大写每个单词!

public String capitalizeText(String name) {
String[] s = name.trim().toLowerCase().split("\\s+");
name = "";
for (String i : s){
if(i.equals("")) return name; // or return anything you want
name+= i.substring(0, 1).toUpperCase() + i.substring(1) + " "; // uppercase first char in words
}
return name.trim();
}

其中一个答案的正确率是95%，但它在我的unitTest中失败了@Ameen Maheen的解决方案几乎完美。除了在输入被转换为String数组之前，您必须修剪输入。所以最完美的一个:

private String convertStringToName(String name) {
name = name.trim();
String[] words = name.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());
}
}
return sb.toString();
}

Java:

简单的一个帮助方法，用于大写每个字符串。

public static String capitalize(String str)
{
if(str == null || str.length()<=1) return str;
return str.substring(0, 1).toUpperCase() + str.substring(1);
}

在此之后，只需调用str = capitalize(str)

芬兰湾的科特林:

str.capitalize()

给出的答案是只大写一个单词的第一个字母。使用以下代码将整个字符串大写。

public static void main(String[] args) {
String str = "this is a random string";
StringBuilder capitalizedString = new StringBuilder();
String[] splited = str.trim().split("\\s+");


for (String string : splited) {
String s1 = string.substring(0, 1).toUpperCase();
String nameCapitalized = s1 + string.substring(1);


capitalizedString.append(nameCapitalized);
capitalizedString.append(" ");
}
System.out.println(capitalizedString.toString().trim());
}

使用替换方法。

String newWord = word.replace(String.valueOf(word.charAt(0)), String.valueOf(word.charAt(0)).toUpperCase());

如果Input是大写，那么使用以下语句:

str.substring(0,1).toUpperCase() + str.substring(1).toLowerCase();

如果输入是小写的，那么使用以下:

str.substring(0,1).toUpperCase() + str.substring(1);

import java.util.*;
public class Program
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
String s1=sc.nextLine();
String[] s2=s1.split(" ");//***split text into words***
ArrayList<String> l = new ArrayList<String>();//***list***
for(String w: s2)
l.add(w.substring(0,1).toUpperCase()+w.substring(1));
//***converting 1st letter to capital and adding to list***
StringBuilder sb = new StringBuilder();//***i used StringBuilder to convert words to text***
for (String s : l)
{
sb.append(s);
sb.append(" ");
}
System.out.println(sb.toString());//***to print output***
}
}

我已经使用split函数将字符串分割成单词，然后我再次使用list来获得该单词的第一个字母大写，然后我使用字符串生成器以字符串格式打印输出，其中包含空格

现有的答案是

• 错误:他们认为char是一个单独的字符(码位)，而它是一个UTF-16字，可以是代理对的一半，或者
• 使用库本身还不错，但需要向项目添加依赖项，或者
• 使用Java 8 Streams，这是完全有效的，但并不总是可能的。

让我们看看代理角色(每个这样的字符都由两个UTF-16单词组成- Java chars)，并且可以有大写和小写变体:

IntStream.rangeClosed(0x01_0000, 0x10_FFFF)
.filter(ch -> Character.toUpperCase(ch) != Character.toLowerCase(ch))
.forEach(ch -> System.out.print(new String(new int[] { ch }, 0, 1)));

它们中的许多对你来说可能看起来像“豆腐”(□)，但它们大多是稀有脚本的有效字符，一些字体支持它们。

例如，让我们看看Deseret Small Letter Long I(𐐨)，U+10428， "\uD801\uDC28":

System.out.println("U+" + Integer.toHexString(
"\uD801\uDC28".codePointAt(0)
)); // U+10428


System.out.println("U+" + Integer.toHexString(
Character.toTitleCase("\uD801\uDC28".codePointAt(0))
)); // U+10400 — ok! capitalized character is another code point


System.out.println("U+" + Integer.toHexString(new String(new char[] {
Character.toTitleCase("\uD801\uDC28".charAt(0)), "\uD801\uDC28".charAt(1)
}).codePointAt(0))); // U+10428 — oops! — cannot capitalize an unpaired surrogate

@Contract("null -> null")
public static CharSequence capitalize(CharSequence input) {
int length;
if (input == null || (length = input.length()) == 0) return input;


return new StringBuilder(length)
.appendCodePoint(Character.toTitleCase(Character.codePointAt(input, 0)))
.append(input, Character.offsetByCodePoints(input, 0, 1), length);
}

并检查它是否有效:

public static void main(String[] args) {
// ASCII
System.out.println(capitalize("whatever")); // w -> W


// UTF-16, no surrogate
System.out.println(capitalize("что-то")); // ч -> Ч


// UTF-16 with surrogate pairs
System.out.println(capitalize("\uD801\uDC28")); // 𐐨 -> 𐐀
}

参见:

• 代理对什么是“代理对”?在Java中?
• 大写与标题大小写https://stackoverflow.com/a/47887432/3050249

当前的答案要么是不正确的，要么是把这个简单的任务过于复杂了。在做了一些研究之后，下面是我想出的两种方法:

1. 字符串的substring()方法

public static String capitalize(String str) {
if(str== null || str.isEmpty()) {
return str;
}


return str.substring(0, 1).toUpperCase() + str.substring(1);
}

例子:

System.out.println(capitalize("java")); // Java
System.out.println(capitalize("beTa")); // BeTa
System.out.println(capitalize(null)); // null

2. Apache Commons Lang

Apache Commons Lang库为此目的提供了StringUtils类:

System.out.println(StringUtils.capitalize("apache commons")); // Apache commons
System.out.println(StringUtils.capitalize("heLLO")); // HeLLO
System.out.println(StringUtils.uncapitalize(null)); // null

不要忘记在你的pom.xml文件中添加以下依赖项:

<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>

简单的解决方案!不需要任何外部库，它可以处理空或一个字母字符串。

private String capitalizeFirstLetter(@NonNull String str){
return str.length() == 0 ? str
: str.length() == 1 ? str.toUpperCase()
: str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();
}

if you use SPRING:

import static org.springframework.util.StringUtils.capitalize;
...




return capitalize(name);

实现: org/springframework/util/StringUtils.java # L535-L555

裁判: javadoc api / org/springframework/util/StringUtils.html #大写

注意:如果你已经有Apache Common Lang依赖，那么考虑使用他们的StringUtils。像其他答案建议的那样大写。

它的效率是101%

public class UpperCase {


public static void main(String [] args) {


String name;


System.out.print("INPUT: ");
Scanner scan = new Scanner(System.in);
name  = scan.next();


String upperCase = name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println("OUTPUT: " + upperCase);


}


}

以下是我关于所有可能选项Android中字符串首字母大写的详细文章

Java中字符串首字母大写的方法

public static String capitalizeString(String str) {
String retStr = str;
try { // We can face index out of bound exception if the string is null
retStr = str.substring(0, 1).toUpperCase() + str.substring(1);
}catch (Exception e){}
return retStr;
}

在KOTLIN中首字母大写的方法

fun capitalizeString(str: String): String {
var retStr = str
try { // We can face index out of bound exception if the string is null
retStr = str.substring(0, 1).toUpperCase() + str.substring(1)
} catch (e: Exception) {
}
return retStr
}

要得到首字母大写和其他想小你可以使用下面的代码。通过substring函数。

String currentGender="mAlE";
currentGender=currentGender.substring(0,1).toUpperCase()+currentGender.substring(1).toLowerCase();

这里substring(0,1). touppercase()转换第一个字母大写，substring(1). tolowercase()转换所有剩余的字母为小写。

输出:

男性

为了使输入字符串的第一个字母大写，我们首先在空格上分割字符串，然后使用地图提供的集合转换过程

<T, R> Array<out T>.map(


transform: (T) -> R


): List<R>

要转换，每个分割的字符串首先小写，然后大写第一个字母。此映射转换将返回一个列表，需要使用joinToString函数将其转换为字符串。

芬兰湾的科特林

fun main() {
    

/*
* Program that first convert all uper case into lower case then
* convert fist letter into uppercase
*/
    

val str = "aLi AzAZ alam"
val calStr = str.split(" ").map{it.toLowerCase().capitalize()}
println(calStr.joinToString(separator = " "))
}

输出

这是我这边的解决方案，所有条件都检查过了。

   import java.util.Objects;


public class CapitalizeFirstCharacter {


public static void main(String[] args) {


System.out.println(capitailzeFirstCharacterOfString("jwala")); //supply input string here
}


private static String capitailzeFirstCharacterOfString(String strToCapitalize) {


if (Objects.nonNull(strToCapitalize) && !strToCapitalize.isEmpty()) {
return strToCapitalize.substring(0, 1).toUpperCase() + strToCapitalize.substring(1);
} else {
return "Null or Empty value of string supplied";


}


}


}

因为您第一次从原始字符串中获得Char。你不能在char上使用String属性，所以先使用to upper，然后使用charAt

String s1 = name.toUppercase().charAt(0);

• 字符char不能存储在String中。
• char和String不能串联。
• String.valueOf()用于将char转换为String

Input

india

Code

String name = "india";
char s1 = name.charAt(0).toUppercase()); // output: 'I'
System.out.println(String.valueOf(s1) + name.substring(1)); // output: "I"+ "ndia";

Output

India

首先你需要这样做——>

//enter here your string values
String output = str.substring(0, 1).toUpperCase() + str.substring(1);


Output will in this way --->
Enter here your string values