O que é metodo compare

3381

Índice Show

Como você compara duas strings em Java?
Qual é a diferença entre o método == equals () e compareTo ()?
Como comparamos duas strings?
É o método igual em Java?
Como o selenium Webdriver compara duas strings em Java?
Como posso comparar duas strings em um array em Java?
O que o método de string compareTo () faz?
Como você verifica se uma string é nula?
o que != Meios em Java?
O que == significa em Python?
Podemos comparar strings usando o operador de igualdade ==?
Comentários
Notas aos Chamadores
Confira também
Aplica-se a

103

Edward Cunningham

Em String, o operador == é usado para comparar a referência das strings fornecidas, dependendo se estão se referindo aos mesmos objetos. Quando você compara duas strings usando o operador ==, ele retornará verdadeiro se as variáveis da string estiverem apontando para o mesmo objeto java. Caso contrário, ele retornará falso .

Como você compara duas strings em Java?

1) Comparação de strings pelo método equals ()

class Teststringcomparison1
public static void main (String args [])
String s1 = "Sachin";
String s2 = "Sachin";
String s3 = nova String ("Sachin");
String s4 = "Saurav";
Sistema.Fora.println (s1.equals (s2)); // verdadeiro.
Sistema.Fora.println (s1.equals (s3)); // verdadeiro.

Qual é a diferença entre o método == equals () e compareTo ()?

A comparação é baseada no valor Unicode de cada caractere nas strings. ... O resultado é um número inteiro positivo se este objeto String segue lexicograficamente a string do argumento. O resultado é zero se as strings forem iguais, compareTo retorna 0 exatamente quando o método equals (Object) retornaria verdadeiro.

Como comparamos duas strings?

5 maneiras de comparar duas strings em Java

Método String Equals.
String é igual a ignorar maiúsculas e minúsculas.
Método de Igualdade de Objeto.
String Compare To Method.
Usando Double Equal To Operator.

É o método igual em Java?

Método Java String equals ()

O método equals () compara duas strings e retorna verdadeiro se as strings são iguais e falso se não. Dica: use o método compareTo () para comparar duas strings lexicograficamente.

Como o selenium Webdriver compara duas strings em Java?

Sintaxe: boolean equals (Object obj); O método equals () compara duas referências e retorna verdadeiro apenas se duas referências estiverem apontando para o mesmo objeto, mas na classe String o método equals compara com base no conteúdo da string. Se o conteúdo é o mesmo em dois objetos diferentes, ele retorna verdadeiro.

Como posso comparar duas strings em um array em Java?

Para comparar o conteúdo do array, a classe Java Arrays fornece os dois métodos a seguir para comparar dois arrays:

Método equals ().
Método deepEquals ().

O que o método de string compareTo () faz?

Método Java String compareTo ()

O método compareTo () compara duas strings lexicograficamente. A comparação é baseada no valor Unicode de cada caractere nas strings. O método retorna 0 se a string for igual à outra string.

Como você verifica se uma string é nula?

Para verificar se uma string é nula ou vazia em Java, use o operador ==. Digamos que temos as seguintes strings. String myStr1 = "Jack Sparrow"; String myStr2 = ""; Vamos verificar as duas strings agora se são nulas ou vazias.

o que != Meios em Java?

Não igual (!=)

O !operador = é um operador de comparação, também usado em expressões condicionais. Diz "diferente". Se os valores comparados não forem iguais, a expressão retorna verdadeiro.

O que == significa em Python?

Há uma diferença sutil entre o operador de identidade Python (é) e o operador de igualdade (==). ... O operador == compara o valor ou igualdade de dois objetos, enquanto o operador Python is verifica se duas variáveis apontam para o mesmo objeto na memória.

Podemos comparar strings usando o operador de igualdade ==?

Você não deve usar == (operador de igualdade) para comparar essas strings porque elas comparam a referência da string, i.e. sejam eles o mesmo objeto ou não. Por outro lado, o método equals () compara se o valor das strings é igual e não o próprio objeto.

O método compareTo da classe String é utilizado para ordenar as Strings alfabeticamente*, e não por tamanho. Desta forma temos que "araraaaaaa" vem antes de "asa", e portanto o compareTo dá -1, porque ao comparar a primeira letra as duas Strings são iguais (a) e ao comparar a segunda, o r vem antes do s.

Para comparar as Strings por tamanho, você deveria invocar o método length das Strings e então comparar os tamanhos diretamente. (Sugestão do Marcelo Bonifazio)

Vale lembrar também que sempre que temos a.compareTo(b) retornando -1 (ou algum outro número negativo) significa que a antecede b, se retorna +1 (ou algum outro número positivo) então a sucede b e se retorna 0 então a e b são similares. Entrentanto a definição exata de "antecede", "sucede" e "similar" fica a critério de cada classe que implementa o compareTo. No caso da classe String a definição é dada pela ordenação alfabética*.

(*) - Na verdade a comparação não é exatamente alfabética, e sim é baseada em comparação de sequências de valores numéricos de codepoints unicode.

public: virtual int CompareTo(System::String ^ strB); public: int CompareTo(System::String ^ strB); public int CompareTo (string strB); public int CompareTo (string? strB); abstract member CompareTo : string -> int override this.CompareTo : string -> int member this.CompareTo : string -> int Public Function CompareTo (strB As String) As Integer Int32

Um inteiro com sinal de 32 bits que indica se esta instância precede, segue ou é exibida na mesma posição da ordem de classificação que o parâmetro strB.

Valor	Condição
Menor que zero	Esta instância precede strB.
Zero	Esta instância tem a mesma posição na ordem de classificação que strB.
Maior que zero	Esta instância segue strB. strB é null.

Exemplos

O exemplo a seguir usa o CompareTo método para comparar a instância de cadeia de caracteres atual com outra cadeia de caracteres.

using namespace System; String^ CompareStrings(String^ str1, String^ str2) { // compare the values, using the CompareTo method on the first string int cmpVal = str1->CompareTo(str2); if (cmpVal == 0) // the values are the same return "The strings occur in the same position in the sort order."; else if (cmpVal < 0) return "The first string precedes the second in the sort order."; else return "The first string follows the second in the sort order."; } int main() { String^ strFirst = "Goodbye"; String^ strSecond = "Hello"; String^ strThird = "a small String*"; String^ strFourth = "goodbye"; // Compare a string to itself. Console::WriteLine(CompareStrings(strFirst, strFirst)); Console::WriteLine(CompareStrings(strFirst, strSecond)); Console::WriteLine(CompareStrings(strFirst, strThird)); // Compare a string to another string that varies only by case. Console::WriteLine(CompareStrings(strFirst, strFourth)); Console::WriteLine(CompareStrings(strFourth, strFirst)); } // The example displays the following output: // The strings occur in the same position in the sort order. // The first string precedes the second in the sort order. // The first string follows the second in the sort order. // The first string follows the second in the sort order. // The first string precedes the second in the sort order. using System; public class Example { public static void Main() { string strFirst = "Goodbye"; string strSecond = "Hello"; string strThird = "a small string"; string strFourth = "goodbye"; // Compare a string to itself. Console.WriteLine(CompareStrings(strFirst, strFirst)); Console.WriteLine(CompareStrings(strFirst, strSecond)); Console.WriteLine(CompareStrings(strFirst, strThird)); // Compare a string to another string that varies only by case. Console.WriteLine(CompareStrings(strFirst, strFourth)); Console.WriteLine(CompareStrings(strFourth, strFirst)); } private static string CompareStrings( string str1, string str2 ) { // Compare the values, using the CompareTo method on the first string. int cmpVal = str1.CompareTo(str2); if (cmpVal == 0) // The strings are the same. return "The strings occur in the same position in the sort order."; else if (cmpVal < 0) return "The first string precedes the second in the sort order."; else return "The first string follows the second in the sort order."; } } // The example displays the following output: // The strings occur in the same position in the sort order. // The first string precedes the second in the sort order. // The first string follows the second in the sort order. // The first string follows the second in the sort order. // The first string precedes the second in the sort order. Public Module Example Public Sub Main() Dim strFirst As String = "Goodbye" Dim strSecond As String = "Hello" Dim strThird As String = "a small string" Dim strFourth As String = "goodbye" ' Compare a string to itself. Console.WriteLine(CompareStrings(strFirst, strFirst)) Console.WriteLine(CompareStrings(strFirst, strSecond)) Console.WriteLine(CompareStrings(strFirst, strThird)) ' Compare a string to another string that varies only by case. Console.WriteLine(CompareStrings(strFirst, strFourth)) Console.WriteLine(CompareStrings(strFourth, strFirst)) End Sub Private Function CompareStrings(str1 As String, str2 As String) As String Dim cmpVal As Integer = str1.CompareTo(str2) If cmpVal = 0 Then ' The values are the same. Return "The strings occur in the same position in the sort order." ElseIf cmpVal < 0 Then Return "The first string precedes the second in the sort order." Else Return "The first string follows the second in the sort order." End If End Function End Module ' This example displays the following output: ' The strings occur in the same position in the sort order. ' The strings occur in the same position in the sort order. ' The first string precedes the second in the sort order. ' The first string follows the second in the sort order. ' The first string follows the second in the sort order. ' The first string precedes the second in the sort order.

O exemplo a seguir demonstra versões genéricas e não genéricas do método CompareTo para vários tipos de valor e referência.

// This example demonstrates the two versions of the // CompareTo method for several base types. // The general version takes a parameter of type Object, while the specific // version takes a type-specific parameter, such as Boolean, Int32, or Double. using namespace System; void Show( String^ caption, Object^ var1, Object^ var2, int resultGeneric, int resultNonGeneric ) { String^ relation; Console::Write( caption ); if ( resultGeneric == resultNonGeneric ) { if ( resultGeneric < 0 ) relation = "less than"; else if ( resultGeneric > 0 ) relation = "greater than"; else relation = "equal to"; Console::WriteLine( "{0} is {1} {2}", var1, relation, var2 ); } // The following condition will never occur because the generic and non-generic // CompareTo methods are equivalent. else { Console::WriteLine( "Generic CompareTo = {0}; non-generic CompareTo = {1}", resultGeneric, resultNonGeneric ); } } int main() { String^ nl = Environment::NewLine; String^ msg = "{0}The following is the result of using the generic and non-generic{0}" "versions of the CompareTo method for several base types:{0}"; Object^ obj; // An Object used to insure CompareTo(Object) is called. DateTime now = DateTime::Now; // Time span = 11 days, 22 hours, 33 minutes, 44 seconds TimeSpan tsX = TimeSpan(11,22,33,44); // Version = 1.2.333.4 Version^ versX = gcnew Version( "1.2.333.4" ); // Guid = CA761232-ED42-11CE-BACD-00AA0057B223 Guid guidX = Guid( "{CA761232-ED42-11CE-BACD-00AA0057B223}"); Boolean a1 = true,a2 = true; Byte b1 = 1,b2 = 1; Int16 c1 = -2,c2 = 2; Int32 d1 = 3,d2 = 3; Int64 e1 = 4,e2 = -4; Decimal f1 = Decimal(-5.5), f2 = Decimal(5.5); Single g1 = 6.6f,g2 = 6.6f; Double h1 = 7.7,h2 = -7.7; Char i1 = 'A',i2 = 'A'; String^ j1 = "abc", ^j2 = "abc"; DateTime k1 = now,k2 = now; TimeSpan l1 = tsX,l2 = tsX; Version^ m1 = versX, ^m2 = gcnew Version( "2.0" ); Guid n1 = guidX,n2 = guidX; // The following types are not CLS-compliant. SByte w1 = 8,w2 = 8; UInt16 x1 = 9,x2 = 9; UInt32 y1 = 10,y2 = 10; UInt64 z1 = 11,z2 = 11; // Console::WriteLine( msg, nl ); try { Show( "Boolean: ", a1, a2, a1.CompareTo( a2 ), a1.CompareTo( a2 ) ); Show( "Byte: ", b1, b2, b1.CompareTo( b2 ), b1.CompareTo( b2 ) ); Show( "Int16: ", c1, c2, c1.CompareTo( c2 ), c1.CompareTo( c2 ) ); Show( "Int32: ", d1, d2, d1.CompareTo( d2 ), d1.CompareTo( d2 ) ); Show( "Int64: ", e1, e2, e1.CompareTo( e2 ), e1.CompareTo( e2 ) ); Show( "Decimal: ", f1, f2, f1.CompareTo( f2 ), f1.CompareTo( f2 ) ); Show( "Single: ", g1, g2, g1.CompareTo( g2 ), g1.CompareTo( g2 ) ); Show( "Double: ", h1, h2, h1.CompareTo( h2 ), h1.CompareTo( h2 ) ); Show( "Char: ", i1, i2, i1.CompareTo( i2 ), i1.CompareTo( i2 ) ); // Use an anonymous object to hide the String object. obj = j2; Show( "String: ", j1, j2, j1->CompareTo( j2 ), j1->CompareTo( obj ) ); Show( "DateTime:", k1, k2, k1.CompareTo( k2 ), k1.CompareTo( k2 ) ); Show( "TimeSpan: ", l1, l2, l1.CompareTo( l2 ), l1.CompareTo( l2 ) ); // Use an anonymous object to hide the Version object. obj = m2; Show( "Version: ", m1, m2, m1->CompareTo( m2 ), m1->CompareTo( obj ) ); Show( "Guid: ", n1, n2, n1.CompareTo( n2 ), n1.CompareTo( n2 ) ); // Console::WriteLine( "{0}The following types are not CLS-compliant:", nl ); Show( "SByte: ", w1, w2, w1.CompareTo( w2 ), w1.CompareTo( w2 ) ); Show( "UInt16: ", x1, x2, x1.CompareTo( x2 ), x1.CompareTo( x2 ) ); Show( "UInt32: ", y1, y2, y1.CompareTo( y2 ), y1.CompareTo( y2 ) ); Show( "UInt64: ", z1, z2, z1.CompareTo( z2 ), z1.CompareTo( z2 ) ); } catch ( Exception^ e ) { Console::WriteLine( e ); } } // This example displays the following output: // // The following is the result of using the generic and non-generic versions of the // CompareTo method for several base types: // // Boolean: True is equal to True // Byte: 1 is equal to 1 // Int16: -2 is less than 2 // Int32: 3 is equal to 3 // Int64: 4 is greater than -4 // Decimal: -5.5 is less than 5.5 // Single: 6.6 is equal to 6.6 // Double: 7.7 is greater than -7.7 // Char: A is equal to A // String: abc is equal to abc // DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM // TimeSpan: 11.22:33:44 is equal to 11.22:33:44 // Version: 1.2.333.4 is less than 2.0 // Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00 // aa0057b223 // // The following types are not CLS-compliant: // SByte: 8 is equal to 8 // UInt16: 9 is equal to 9 // UInt32: 10 is equal to 10 // UInt64: 11 is equal to 11 // This example demonstrates the generic and non-generic versions of the // CompareTo method for several base types. // The non-generic version takes a parameter of type Object, while the generic // version takes a type-specific parameter, such as Boolean, Int32, or Double. using System; class Sample { public static void Main() { string nl = Environment.NewLine; string msg = "{0}The following is the result of using the generic and non-generic{0}" + "versions of the CompareTo method for several base types:{0}"; DateTime now = DateTime.Now; // Time span = 11 days, 22 hours, 33 minutes, 44 seconds TimeSpan tsX = new TimeSpan(11, 22, 33, 44); // Version = 1.2.333.4 Version versX = new Version("1.2.333.4"); // Guid = CA761232-ED42-11CE-BACD-00AA0057B223 Guid guidX = new Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}"); Boolean a1 = true, a2 = true; Byte b1 = 1, b2 = 1; Int16 c1 = -2, c2 = 2; Int32 d1 = 3, d2 = 3; Int64 e1 = 4, e2 = -4; Decimal f1 = -5.5m, f2 = 5.5m; Single g1 = 6.6f, g2 = 6.6f; Double h1 = 7.7d, h2 = -7.7d; Char i1 = 'A', i2 = 'A'; String j1 = "abc", j2 = "abc"; DateTime k1 = now, k2 = now; TimeSpan l1 = tsX, l2 = tsX; Version m1 = versX, m2 = new Version("2.0"); Guid n1 = guidX, n2 = guidX; // The following types are not CLS-compliant. SByte w1 = 8, w2 = 8; UInt16 x1 = 9, x2 = 9; UInt32 y1 = 10, y2 = 10; UInt64 z1 = 11, z2 = 11; // Console.WriteLine(msg, nl); try { // The second and third Show method call parameters are automatically boxed because // the second and third Show method declaration arguments expect type Object. Show("Boolean: ", a1, a2, a1.CompareTo(a2), a1.CompareTo((Object)a2)); Show("Byte: ", b1, b2, b1.CompareTo(b2), b1.CompareTo((Object)b2)); Show("Int16: ", c1, c2, c1.CompareTo(c2), c1.CompareTo((Object)c2)); Show("Int32: ", d1, d2, d1.CompareTo(d2), d1.CompareTo((Object)d2)); Show("Int64: ", e1, e2, e1.CompareTo(e2), e1.CompareTo((Object)e2)); Show("Decimal: ", f1, f2, f1.CompareTo(f2), f1.CompareTo((Object)f2)); Show("Single: ", g1, g2, g1.CompareTo(g2), g1.CompareTo((Object)g2)); Show("Double: ", h1, h2, h1.CompareTo(h2), h1.CompareTo((Object)h2)); Show("Char: ", i1, i2, i1.CompareTo(i2), i1.CompareTo((Object)i2)); Show("String: ", j1, j2, j1.CompareTo(j2), j1.CompareTo((Object)j2)); Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo((Object)k2)); Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo((Object)l2)); Show("Version: ", m1, m2, m1.CompareTo(m2), m1.CompareTo((Object)m2)); Show("Guid: ", n1, n2, n1.CompareTo(n2), n1.CompareTo((Object)n2)); // Console.WriteLine("{0}The following types are not CLS-compliant:", nl); Show("SByte: ", w1, w2, w1.CompareTo(w2), w1.CompareTo((Object)w2)); Show("UInt16: ", x1, x2, x1.CompareTo(x2), x1.CompareTo((Object)x2)); Show("UInt32: ", y1, y2, y1.CompareTo(y2), y1.CompareTo((Object)y2)); Show("UInt64: ", z1, z2, z1.CompareTo(z2), z1.CompareTo((Object)z2)); } catch (Exception e) { Console.WriteLine(e); } } public static void Show(string caption, Object var1, Object var2, int resultGeneric, int resultNonGeneric) { string relation; Console.Write(caption); if (resultGeneric == resultNonGeneric) { if (resultGeneric < 0) relation = "less than"; else if (resultGeneric > 0) relation = "greater than"; else relation = "equal to"; Console.WriteLine("{0} is {1} {2}", var1, relation, var2); } // The following condition will never occur because the generic and non-generic // CompareTo methods are equivalent. else { Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}", resultGeneric, resultNonGeneric); } } } /* This example produces the following results: The following is the result of using the generic and non-generic versions of the CompareTo method for several base types: Boolean: True is equal to True Byte: 1 is equal to 1 Int16: -2 is less than 2 Int32: 3 is equal to 3 Int64: 4 is greater than -4 Decimal: -5.5 is less than 5.5 Single: 6.6 is equal to 6.6 Double: 7.7 is greater than -7.7 Char: A is equal to A String: abc is equal to abc DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM TimeSpan: 11.22:33:44 is equal to 11.22:33:44 Version: 1.2.333.4 is less than 2.0 Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00 aa0057b223 The following types are not CLS-compliant: SByte: 8 is equal to 8 UInt16: 9 is equal to 9 UInt32: 10 is equal to 10 UInt64: 11 is equal to 11 */ ' This example demonstrates the generic and non-generic versions of the ' CompareTo method for several base types. ' The non-generic version takes a parameter of type Object, while the generic ' version takes a type-specific parameter, such as Boolean, Int32, or Double. Class Sample Public Shared Sub Main() Dim nl As String = Environment.NewLine Dim msg As String = _ "{0}The following is the result of using the generic and non-generic{0}" & _ "versions of the CompareTo method for several base types:{0}" Dim now As DateTime = DateTime.Now ' Time span = 11 days, 22 hours, 33 minutes, 44 seconds Dim tsX As New TimeSpan(11, 22, 33, 44) ' Version = 1.2.333.4 Dim versX As New Version("1.2.333.4") ' Guid = CA761232-ED42-11CE-BACD-00AA0057B223 Dim guidX As New Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}") Dim a1 As [Boolean] = True, a2 As [Boolean] = True Dim b1 As [Byte] = 1, b2 As [Byte] = 1 Dim c1 As Int16 = -2, c2 As Int16 = 2 Dim d1 As Int32 = 3, d2 As Int32 = 3 Dim e1 As Int64 = 4, e2 As Int64 = -4 Dim f1 As [Decimal] = -5.5D, f2 As [Decimal] = 5.5D Dim g1 As [Single] = 6.6F, g2 As [Single] = 6.6F Dim h1 As [Double] = 7.7, h2 As [Double] = -7.7 Dim i1 As [Char] = "A"c, i2 As [Char] = "A"c Dim j1 As String = "abc", j2 As String = "abc" Dim k1 As DateTime = now, k2 As DateTime = now Dim l1 As TimeSpan = tsX, l2 As TimeSpan = tsX Dim m1 As Version = versX, m2 As New Version("2.0") Dim n1 As Guid = guidX, n2 As Guid = guidX ' The following types are not CLS-compliant. ' SByte, UInt16, UInt32, UInt64 Console.WriteLine(msg, nl) Try ' The second and third Show method call parameters are automatically boxed because ' the second and third Show method declaration arguments expect type Object. Show("Boolean: ", a1, a2, a1.CompareTo(a2), a1.CompareTo(CObj(a2))) Show("Byte: ", b1, b2, b1.CompareTo(b2), b1.CompareTo(CObj(b2))) Show("Int16: ", c1, c2, c1.CompareTo(c2), c1.CompareTo(CObj(c2))) Show("Int32: ", d1, d2, d1.CompareTo(d2), d1.CompareTo(CObj(d2))) Show("Int64: ", e1, e2, e1.CompareTo(e2), e1.CompareTo(CObj(e2))) Show("Decimal: ", f1, f2, f1.CompareTo(f2), f1.CompareTo(CObj(f2))) Show("Single: ", g1, g2, g1.CompareTo(g2), g1.CompareTo(CObj(g2))) Show("Double: ", h1, h2, h1.CompareTo(h2), h1.CompareTo(CObj(h2))) Show("Char: ", i1, i2, i1.CompareTo(i2), i1.CompareTo(CObj(i2))) Show("String: ", j1, j2, j1.CompareTo(j2), j1.CompareTo(CObj(j2))) Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo(CObj(k2))) Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo(CObj(l2))) Show("Version: ", m1, m2, m1.CompareTo(m2), m1.CompareTo(CObj(m2))) Show("Guid: ", n1, n2, n1.CompareTo(n2), n1.CompareTo(CObj(n2))) ' Console.WriteLine("{0}The following types are not CLS-compliant:", nl) Console.WriteLine("SByte, UInt16, UInt32, UInt64") Catch e As Exception Console.WriteLine(e) End Try End Sub Public Shared Sub Show(caption As String, var1 As [Object], var2 As [Object], _ resultGeneric As Integer, resultNonGeneric As Integer) Dim relation As String Console.Write(caption) If resultGeneric = resultNonGeneric Then If resultGeneric < 0 Then relation = "less than" ElseIf resultGeneric > 0 Then relation = "greater than" Else relation = "equal to" End If Console.WriteLine("{0} is {1} {2}", var1, relation, var2) ' The following condition will never occur because the generic and non-generic ' CompareTo methods are equivalent. Else Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}", _ resultGeneric, resultNonGeneric) End If End Sub End Class ' 'This example produces the following results: ' 'The following is the result of using the generic and non-generic versions of the 'CompareTo method for several base types: ' 'Boolean: True is equal to True 'Byte: 1 is equal to 1 'Int16: -2 is less than 2 'Int32: 3 is equal to 3 'Int64: 4 is greater than -4 'Decimal: -5.5 is less than 5.5 'Single: 6.6 is equal to 6.6 'Double: 7.7 is greater than -7.7 'Char: A is equal to A 'String: abc is equal to abc 'DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM 'TimeSpan: 11.22:33:44 is equal to 11.22:33:44 'Version: 1.2.333.4 is less than 2.0 'Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00 'aa0057b223 ' 'The following types are not CLS-compliant: 'SByte, UInt16, UInt32, UInt64 '

Comentários

Este método executa uma comparação de palavra (diferencia maiúsculas de minúsculas e sensível à cultura) usando a cultura atual. Para obter mais informações sobre a palavra, a cadeia de caracteres e os tipos ordinais, consulte System.Globalization.CompareOptions.

Cuidado

O CompareTo método foi projetado principalmente para uso em operações de classificação ou alfabética. Ele não deve ser usado quando a principal finalidade da chamada de método é determinar se duas cadeias de caracteres são equivalentes. Para determinar se duas cadeias de caracteres são equivalentes, chame o método Equals.

Para obter mais informações sobre o comportamento desse método, consulte a seção Comentários do Compare(String, String) método .

Esse método implementa a interface e tem um desempenho ligeiramente melhor do que o método , porque ele não precisa determinar se o argumento é um tipo de valor mutável que deve ser análido e não precisa castrá-lo de um para System.IComparable<T> String.CompareTo(Object) um strB Object String .

Notas aos Chamadores

Entre conjuntos de caracteres estão caracteres ignoráveis. O CompareTo(String) método não considera esses caracteres quando executa uma comparação sensível à cultura. Por exemplo, se o código a seguir for executado no .NET Framework 4 ou posterior, uma comparação de "animal" com "ani-mal" (usando um hífen suave ou U+00AD) indicará que as duas cadeias de caracteres são equivalentes.

using System; public class Example { public static void Main() { string s1 = "ani\u00ADmal"; string s2 = "animal"; Console.WriteLine("Comparison of '{0}' and '{1}': {2}", s1, s2, s1.CompareTo(s2)); } } // The example displays the following output: // Comparison of 'ani-mal' and 'animal': 0 Module Example Public Sub Main() Dim s1 As String = "ani" + ChrW(&h00AD) + "mal" Dim s2 As String = "animal" Console.WriteLine("Comparison of '{0}' and '{1}': {2}", s1, s2, s1.CompareTo(s2)) End Sub End Module ' The example displays the following output: ' Comparison of 'ani-mal' and 'animal': 0

Para reconhecer caracteres ignoráveis em uma comparação de cadeia de caracteres, chame o CompareOrdinal(String, String) método .