制作字符串大写的第一个字母（具有最大性能）-Java 学习之路

371

我有一个带有 TextBox 的 DetailsView ，我希望输入数据始终保存在FIRST LETTER IN CAPITAL中 .

Example:

"red" --> "Red"
"red house" --> " Red house"

我怎么能实现这个 maximizing performance ？

NOTE ：
根据答案和答案下的评论，许多人认为这是在询问字符串中所有单词的大写 . 例如 . => Red House It isn't, but if that is what you seek ，寻找使用 TitleInfo 的 ToTitleCase 方法的答案之一 . （注意：对于实际提出的问题，这些答案是不正确的 . ）
有关警告，请参阅TextInfo.ToTitleCase doc（不触及所有大写单词 - 它们被视为首字母缩略词;可以降低单词中间的小写字母，例如"McDonald" => "Mcdonald";不保证能够处理所有特定于文化的细微差别重写大写规则 . ）

NOTE ：
关于第一个字母之后的字母是否应该是小写的问题是不明确的 . 接受的答案假定只应改变第一个字母 . 如果要强制除第一个字符串之外的字符串中的所有字母都是小写，请查找包含 ToLower 且不包含ToTitleCase的答案 .

30 回答

这是最快的方式：

public static unsafe void ToUpperFirst(this string str)
{
    if (str == null) return;
    fixed (char* ptr = str) 
        *ptr = char.ToUpper(*ptr);
}

无需更改原始字符串：

public static unsafe string ToUpperFirst(this string str)
{
    if (str == null) return null;
    string ret = string.Copy(str);
    fixed (char* ptr = ret) 
        *ptr = char.ToUpper(*ptr);
    return ret;
}

回复于 2024-04-24T05:27:40+08:00

资本化冷杉信的最简单方法是：

1-使用Sytem.Globalization;

// Creates a TextInfo based on the "en-US" culture.
  TextInfo myTI = new CultureInfo("en-US",false).

  myTI.ToTitleCase(textboxname.Text)

回复于 2024-04-24T05:27:40+08:00

EDIT: 更新为更新的语法（以及更正确的答案），也作为扩展方法 .

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input)
    {
        switch (input)
        {
            case null: throw new ArgumentNullException(nameof(input));
            case "": throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input));
            default: return input.First().ToString().ToUpper() + input.Substring(1);
        }
    }
}

OLD ANSWERS

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

EDIT ：这个版本更短 . 如需更快的解决方案，请查看Equiso's answer

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

EDIT 2 ：可能最快的解决方案是Darren's（有's even a benchmark) although I would change it' s string.IsNullOrEmpty(s) 验证抛出异常，因为原始要求期望第一个字母存在，因此它可以是大写的 . 请注意，此代码适用于通用字符串，而不是特别适用于有效值来自 Textbox .

回复于 2024-04-24T05:27:40+08:00

public string FirstLetterToUpper(string str)
{
    if (str == null)
        return null;

    if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

    return str.ToUpper();
}

旧答案：这使得每个第一个字母大写

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}

回复于 2024-04-24T05:27:40+08:00

1
正确的方法是使用文化：
```
Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())
```
Note: 这将大写字符串中的每个单词，例如"red house" - > "Red House" . 该解决方案还将在单词内进行小写大小写，例如"old McDonald" - > "Old Mcdonald" .
回复于 2024-04-24T05:27:40+08:00

这样做虽然它也会确保没有错误的大写字母不在单词的开头 .

public string(string s)
{
System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
System.Globalization.TextInfo t = c.TextInfo;

return t.ToTitleCase(s);
}

回复于 2024-04-24T05:27:40+08:00

-1

我从http://www.dotnetperls.com/uppercase-first-letter采取了最快的方法并转换为扩展方法：

/// <summary>
    /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
    /// </summary>
    public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

注意：使用 ToCharArray 的原因比替代 char.ToUpper(s[0]) + s.Substring(1) 快，是只分配了一个字符串，而 Substring 方法为子字符串分配字符串，然后是第二个字符串来组成最终结果 .

EDIT ：这是这种方法的样子，结合CarlosMuñoz accepted answer的初始测试：

/// <summary>
    /// Returns the input string with the first character converted to uppercase
    /// </summary>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrEmpty(s))
            throw new ArgumentException("There is no first letter");

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

回复于 2024-04-24T05:27:40+08:00

你可以使用“ToTitleCase方法”

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

这种扩展方法解决了每个 Headers 问题 .

易于使用

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

扩展方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Test
{
    public static class StringHelper
    {
        private static CultureInfo ci = new CultureInfo("en-US");
        //Convert all first latter
        public static string ToTitleCase(this string str)
        {
            str = str.ToLower();
            var strArray = str.Split(' ');
            if (strArray.Length > 1)
            {
                strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                return string.Join(" ", strArray);
            }
            return ci.TextInfo.ToTitleCase(str);
        }
        public static string ToTitleCase(this string str, TitleCase tcase)
        {
            str = str.ToLower();
            switch (tcase)
            {
                case TitleCase.First:
                    var strArray = str.Split(' ');
                    if (strArray.Length > 1)
                    {
                        strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                        return string.Join(" ", strArray);
                    }
                    break;
                case TitleCase.All:
                    return ci.TextInfo.ToTitleCase(str);
                default:
                    break;
            }
            return ci.TextInfo.ToTitleCase(str);
        }
    }

    public enum TitleCase
    {
        First,
        All
    }
}

回复于 2024-04-24T05:27:40+08:00

对于第一个字母，进行错误检查：

public string CapitalizeFirstLetter(string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

这里有一个方便的扩展

public static string CapitalizeFirstLetter(this string s)
    {
    if (String.IsNullOrEmpty(s)) return s;
    if (s.Length == 1) return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
    }

回复于 2024-04-24T05:27:40+08:00

public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}

回复于 2024-04-24T05:27:40+08:00

如果性能/内存使用是一个问题，那么这个只创建一（1）个StringBuilder和一（1）个与原始字符串大小相同的新String .

public static string ToUpperFirst(this string str) {
  if( !string.IsNullOrEmpty( str ) ) {
    StringBuilder sb = new StringBuilder(str);
    sb[0] = char.ToUpper(sb[0]);

    return sb.ToString();

  } else return str;
}

回复于 2024-04-24T05:27:40+08:00

试试这个：

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}

回复于 2024-04-24T05:27:40+08:00

这是一种将其作为扩展方法的方法：

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

然后可以被称为：

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter();

这里有一些单元测试：

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian's test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian's test.", result);
}

回复于 2024-04-24T05:27:40+08:00

1
因为我也碰巧正在研究这个问题，并且正在寻找任何想法，这就是我的解决方案 . 它使用LINQ，并且能够大写字符串的第一个字母，即使第一个字母不是字母 . 这是我最终制作的扩展方法 .
```
public static string CaptalizeFirstLetter(this string data)
{
    var chars = data.ToCharArray();

    // Find the Index of the first letter
    var charac = data.First(char.IsLetter);
    var i = data.IndexOf(charac);

    // capitalize that letter
    chars[i] = char.ToUpper(chars[i]);

    return new string(chars);
}
```
我确信有一种方法可以优化或清理它 .
回复于 2024-04-24T05:27:40+08:00

461

我在这里找到了一些东西http://www.dotnetperls.com/uppercase-first-letter：

static string UppercaseFirst(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
    return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}

也许这有帮助!!

回复于 2024-04-24T05:27:40+08:00

3
如果您只关心第一个字母大写，并且字符串的其余部分无关紧要，您可以选择第一个字符，将其设置为大写，并将其与字符串的其余部分连接，而不使用原始的第一个字符 .
```
String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"
```
我们需要转换第一个字符ToString（），因为我们将它作为Char数组读取，而Char类型没有ToUpper（）方法 .
回复于 2024-04-24T05:27:40+08:00

当你需要的时候，似乎有很多复杂性：

/// <summary>
    /// Returns the input string with the first character converted to uppercase if a letter
    /// </summary>
    /// <remarks>Null input returns null</remarks>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return s;

        return char.ToUpper(s[0]) + s.Substring(1);
    }

值得注意的要点：

它是一种扩展方法 .
如果输入为null，为空或空格，则按原样返回输入 .
String.IsNullOrWhiteSpace被介绍了使用.NET Framework 4.这不适用于旧框架 .

回复于 2024-04-24T05:27:40+08:00

最快的方法 .

private string Capitalize(string s){
        if (string.IsNullOrEmpty(s))
        {
            return string.Empty;
        }
        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
}

测试显示下一个结果（输入10000000个符号的字符串）：Test results

回复于 2024-04-24T05:27:40+08:00

283

string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();

回复于 2024-04-24T05:27:40+08:00

3
我想提供一个“最大性能”的答案 . 在我看来，“最大性能”答案捕获了所有场景，并提供了解决这些场景的问题的答案 . 所以，这是我的答案 . 有这些原因：
- IsNullOrWhiteSpace考虑只是空格或空/空的字符串 .
- .Trim（）从字符串的正面和背面删除空格 .
- .First（）接受一个ienumerable（或字符串）的第一个字符 .
- 我们应该检查它是否是一个可以/应该是大写的字母 .
- 然后我们添加字符串的其余部分，只有长度表示我们应该 .
- 通过.Net最佳实践，我们应该在System.Globalization.CultureInfo下提供一种文化 .
- 将它们作为可选参数提供使得此方法完全可重用，无需每次都键入所选文化 .
```
public static string capString(string instring, string culture = "en-US", bool useSystem = false)
{
    string outstring;
    if (String.IsNullOrWhiteSpace(instring))
    {
        return "";
    }
    instring = instring.Trim();
    char thisletter = instring.First();
    if (!char.IsLetter(thisletter))
    {
        return instring;   
    }
    outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
    if (instring.Length > 1)
    {
        outstring += instring.Substring(1);
    }
    return outstring;
}
```
回复于 2024-04-24T05:27:40+08:00

我认为以下方法是最好的解决方案

class Program
{
    static string UppercaseWords(string value)
    {
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
        return new string(array);
    }

    static void Main()
    {
        // Uppercase words in these strings.
        const string value1 = "something in the way";
        const string value2 = "dot net PERLS";
        const string value3 = "String_two;three";
        const string value4 = " sam";
        // ... Compute the uppercase strings.
        Console.WriteLine(UppercaseWords(value1));
        Console.WriteLine(UppercaseWords(value2));
        Console.WriteLine(UppercaseWords(value3));
        Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

ref

回复于 2024-04-24T05:27:40+08:00

这将第一个字母和每个字母后面的空格和小写字母大写任何其他字母 .

public string CapitalizeFirstLetterAfterSpace(string input)
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
    bool capitalizeNextLetter = true;
    for(int pos = 0; pos < sb.Length; pos++)
    {
        if(capitalizeNextLetter)
        {
            sb[pos]=System.Char.ToUpper(sb[pos]);
            capitalizeNextLetter = false;
        }
        else
        {
            sb[pos]=System.Char.ToLower(sb[pos]);
        }

        if(sb[pos]=' ')
        {
            capitalizeNextLetter=true;
        }
    }
}

回复于 2024-04-24T05:27:40+08:00

Use the following code:

string  strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();

回复于 2024-04-24T05:27:40+08:00

0
似乎这里给出的解决方案都不会在字符串之前处理空格 .

只是添加这个想法：
```
public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
    if (string.IsNullOrWhiteSpace(aValue))
        return aValue;

    string trimmed = aIgonreLeadingSpaces 
           ? aValue.TrimStart() 
           : aValue;

    return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}
```
它应该处理 this won't work on other answers （该句子在开头有空格），如果你不喜欢空格修剪，只需传递一个 false 作为第二个参数（或者将默认值更改为 false ，如果你想处理，则传递 true 空间）
回复于 2024-04-24T05:27:40+08:00
1

FluentSharp具有 lowerCaseFirstLetter 方法，可以执行此操作

https://github.com/o2platform/FluentSharp/blob/700dc35759db8e2164771a71f73a801aa9379074/FluentSharp.CoreLib/ExtensionMethods/System/String_ExtensionMethods.cs#L575

回复于 2024-04-24T05:27:40+08:00

以下功能适用于所有方式：

static string UppercaseWords(string value)
{
    char[] array = value.ToCharArray();
    // Handle the first letter in the string.
    if (array.Length >= 1)
    {
        if (char.IsLower(array[0]))
        {
            array[0] = char.ToUpper(array[0]);
        }
    }
    // Scan through the letters, checking for spaces.
    // ... Uppercase the lowercase letters following spaces.
    for (int i = 1; i < array.Length; i++)
    {
        if (array[i - 1] == ' ')
        {
            if (char.IsLower(array[i]))
            {
                array[i] = char.ToUpper(array[i]);
            }
        }
    }
    return new string(array);
}

我发现here

回复于 2024-04-24T05:27:40+08:00

扩展上面的卡洛斯问题，如果你想要多个句子，你可以使用这个代码：

/// <summary>
    /// Capitalize first letter of every sentence. 
    /// </summary>
    /// <param name="inputSting"></param>
    /// <returns></returns>
    public string CapitalizeSentences (string inputSting)
    {
        string result = string.Empty;
        if (!string.IsNullOrEmpty(inputSting))
        {
            string[] sentences = inputSting.Split('.');

            foreach (string sentence in sentences)
            {
                result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1)); 
            }
        }

        return result; 
    }

回复于 2024-04-24T05:27:40+08:00

-1
最近我有类似的要求，并记得LINQ函数Select（）提供了一个索引：
```
string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"
```
由于我经常需要，我为字符串类型创建了一个扩展方法：
```
public static class StringExtensions
{
    public static string FirstLetterToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;
        return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
    }
}
```
请注意，只有第一个字母转换为大写字母 - 所有剩余的字符都不会被触及 . 如果你需要其他字符为小写，你也可以调用Char.ToLower（currentChar）索引> 0或者首先在整个字符串上调用ToLower（） .

关于性能，我将代码与Darren的解决方案进行了比较 . 在我的机器上，Darren的代码大约快2倍，这并不奇怪，因为他只是直接编辑char数组中的第一个字母 . 因此，如果您需要最快的解决方案，我建议您使用Darren的代码 . 如果你想集成其他的字符串操作，也可以方便地使lambda函数的表达能力接触输入字符串的字符 - 你可以很容易地扩展这个函数 - 所以我在这里留下这个解决方案 .
回复于 2024-04-24T05:27:40+08:00

使用此方法，您可以高举每个单词的第一个字符 .

示例“HeLlo wOrld”=>“Hello World”

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("Error");
    return string.Join(" ", input.Split(' ').Select(d => d.First().ToString().ToUpper() +  d.ToLower().Substring(1)));
}

回复于 2024-04-24T05:27:40+08:00

123

发送一个字符串到这个函数 . 它会首先检查字符串是空还是空，如果不是字符串将是所有较低的字符 . 然后返回字符串上面的其余部分的第一个字符 .

string FirstUpper(string s)
    {
        // Check for empty string.
        if (string.IsNullOrEmpty(s))
        {
            return string.Empty;
        }
        s = s.ToLower();
        // Return char and concat substring.
        return char.ToUpper(s[0]) + s.Substring(1);
    }

回复于 2024-04-24T05:27:40+08:00

制作字符串大写的第一个字母（具有最大性能）

30 回答

相关问题