C 语言中字符串比较方法的差异#

来自 MSDN：

“CompareTo 方法主要用于排序或 按字母顺序排列操作。当主要 方法调用的用途是确定两个字符串是否 等效。要确定两个字符串是否等效，请调用 Equals 方法。

他们建议在仅仅寻求平等时使用而不是使用。我不确定班级之间和班级之间是否有区别。我有时会用 或 代替我自己的类，以防以后有人出现并重新定义该类的运算符。.Equals.CompareTo.Equals==string.EqualsObject.ReferenceEquals====

在你在这里列出的表格中，两者之间没有太大区别。 最终调用一个使用当前区域性进行比较的方法; 由操作员调用。CompareToCompareInfoEquals==

如果你考虑过载，那么事情就会变得不同。 并且只能使用当前区域性来比较字符串。 并且可以采用一个枚举参数，该参数允许您指定不区分区域性或不区分大小写的比较。仅允许您指定和使用默认区域性以外的区域性执行比较。Compare==EqualsString.CompareStringComparisonString.CompareCultureInfo

由于它的多功能性，我发现我使用的比任何其他比较方法都多;它让我可以准确地指定我想要什么。String.Compare

用。Equals 也更容易阅读。

并不是说性能通常很重要，因为 99% 的时间你需要这样做，但是如果你不得不在数百万次的循环中执行此操作，我强烈建议你使用 .等于或 ==，因为一旦它找到一个不匹配的字符，它就会将整个内容抛出为 false，但如果您使用 CompareTo，它将不得不找出哪个字符小于另一个字符，从而导致性能时间稍差。

如果你的应用将在不同的国家/地区运行，我建议你看看 CultureInfo 的含义，并可能使用 .等于。由于我只真正为美国编写应用程序（并且不在乎它是否不能由某人正常工作），因此我总是只使用 ==。

Here are the rules for how these functions work:

stringValue.CompareTo(otherStringValue)

1. null comes before a string
2. it uses , which means it will use a culture-dependent comparison. This might mean that will compare equal to in Germany, or similarCultureInfo.CurrentCulture.CompareInfo.CompareßSS

stringValue.Equals(otherStringValue)

1. null is not considered equal to anything
2. unless you specify a option, it will use what looks like a direct ordinal equality check, i.e. is not the same as , in any language or cultureStringComparisonßSS

stringValue == otherStringValue

1. Is not the same as .stringValue.Equals()
2. The operator calls the static method (which in turn goes to an internal to do the comparison.==Equals(string a, string b)EqualsHelper
3. Calling on a string gets reference exception, while on does not..Equals()nullnull==

Object.ReferenceEquals(stringValue, otherStringValue)

Just checks that references are the same, i.e. it isn't just two strings with the same contents, you're comparing a string object with itself.

---

Note that with the options above that use method calls, there are overloads with more options to specify how to compare.

My advice if you just want to check for equality is to make up your mind whether you want to use a culture-dependent comparison or not, and then use or , depending on the choice..CompareTo.Equals

If you are ever curious about differences in BCL methods, Reflector is your friend :-)

I follow these guidelines:

Exact match: _{EDIT: I previously always used == operator on the principle that inside Equals(string, string) the object == operator is used to compare the object references but it seems strA.Equals(strB) is still 1-11% faster overall than string.Equals(strA, strB), strA == strB, and string.CompareOrdinal(strA, strB). I loop tested with a StopWatch on both interned/non-interned string values, with same/different string lengths, and varying sizes (1B to 5MB).}

strA.Equals(strB)

Human-readable match (Western cultures, case-insensitive):

string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase) == 0

Human-readable match (All other cultures, insensitive case/accent/kana/etc defined by CultureInfo):

string.Compare(strA, strB, myCultureInfo) == 0

Human-readable match with custom rules (All other cultures):

CompareOptions compareOptions = CompareOptions.IgnoreCase
                              | CompareOptions.IgnoreWidth
                              | CompareOptions.IgnoreNonSpace;
string.Compare(strA, strB, CultureInfo.CurrentCulture, compareOptions) == 0

正如 Ed 所说，CompareTo 用于排序。

但是，两者之间是有区别的。等于 和 ==。

== 解析为以下代码：

if(object.ReferenceEquals(left, null) && 
   object.ReferenceEquals(right, null))
    return true;
if(object.ReferenceEquals(left, null))
    return right.Equals(left);
return left.Equals(right);

原因很简单，以下内容将引发异常：

string a = null;
string b = "foo";

bool equal = a.Equals(b);

以下不会：

string a = null;
string b = "foo";

bool equal = a == b;

跟。等于，您还将获得 StringComparison 选项。非常方便忽略案例和其他事情。

顺便说一句，这将计算为 false

string a = "myString";
string b = "myString";

return a==b

由于 == 比较 a 和 b（指针）的值，因此仅当指针指向内存中的同一对象时，其计算结果为 true。.Equals 取消引用指针并比较指针中存储的值。 a.Equals（b） 在这里为真。

如果将 b 更改为：

b = "MYSTRING";

则 a.Equals（b） 为 false，但

a.Equals(b, StringComparison.OrdinalIgnoreCase) 

是真的

a.CompareTo（b） 调用字符串的 CompareTo 函数，该函数比较指针处的值，如果存储在 a 处的值小于存储在 b 处的值，则返回 <0，如果 a.Equals（b） 为 true，则返回 0，否则返回 >0。但是，这是区分大小写的，我认为 CompareTo 可能有一些选项可以忽略大小写等，但现在没有时间查看。 正如其他人已经说过的那样，这将用于排序。以这种方式比较平等将导致不必要的开销。

我确定我遗漏了一些东西，但我认为如果您需要更多详细信息，这应该足以开始实验。

有关字符串比较问题的良好解释和做法，请参阅在 Microsoft .NET 2.0 中使用字符串的新建议一文，以及在 .NET Framework 中使用字符串的最佳做法。

---

提到的每种方法（和其他方法）都有特定的用途。它们之间的主要区别在于它们默认使用的 StringComparison 枚举类型。有几种选择：

• 当前文化
• CurrentCultureIgnoreCase
• InvariantCulture （不变文化）
• InvariantCultureIgnoreCase
• 序数
• OrdinalIgnoreCase

上述每种比较类型都针对不同的用例：

• 序数
  • 区分大小写的内部标识符
  • XML 和 HTTP 等标准中区分大小写的标识符
  • 区分大小写的安全相关设置
• OrdinalIgnoreCase
  • 不区分大小写的内部标识符
  • XML 和 HTTP 等标准中不区分大小写的标识符
  • 文件路径（在 Microsoft Windows 上）
  • 注册表项/值
  • 环境变量
  • 资源标识符（例如句柄名称）
  • 不区分大小写的安全性相关设置
• InvariantCulture 或 InvariantCultureIgnoreCase
  • 一些人保留了与语言相关的数据
  • 显示需要固定排序顺序的语言数据
• CurrentCulture 或 CurrentCultureIgnoreCase
  • 向用户显示的数据
  • 大多数用户输入

请注意，自 .NET 2.0 以来，StringComparison 枚举以及字符串比较方法的重载就存在。

---

String.CompareTo 方法 （String）

实际上是 IComparable.CompareTo 方法的类型安全实现。默认解释：CurrentCulture。

用法：

CompareTo 方法主要用于排序或按字母顺序排列操作

因此

Implementing the IComparable interface will necessarily use this method

String.Compare Method

A static member of String Class which has many overloads. Default interpretation: CurrentCulture.

Whenever possible, you should call an overload of the Compare method that includes a StringComparison parameter.

String.Equals 方法

从 Object 类中重写并重载以实现类型安全。默认解释：序数。 请注意：

String 类的相等方法包括静态 Equals、静态运算符 == 和实例方法 Equals。

---

StringComparer 类

还有另一种处理字符串比较的方法，特别是针对排序：

可以使用 StringComparer 类创建特定于类型的比较，以对泛型集合中的元素进行排序。Hashtable、Dictionary、SortedList 和 SortedList 等类使用 StringComparer 类进行排序。

需要注意的一个很大区别是。如果第一个字符串为 null，Equals（） 将抛出异常，而 == 不会。

       string s = null;
        string a = "a";
        //Throws {"Object reference not set to an instance of an object."}
        if (s.Equals(a))
            Console.WriteLine("s is equal to a");
        //no Exception
        if(s==a)
            Console.WriteLine("s is equal to a");

• S1 中。CompareTo（s2）：如果主要目的是确定两个字符串是否等效，则不要使用
• s1 == s2：不能忽略大小写
• S1 中。Equals（s2， StringComparison）：如果 s1 为 null，则引发 NullReferenceException
• String.Equals（s2， StringComparison）：通过消除过程，这个静态方法是 WINNER（假设一个典型的用例来确定两个字符串是否等效）！