BigInteger.CompareTo Método

Definição

Compara o valor desta instância com outro valor e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o outro valor.Compares the value of this instance with another value and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the other value.

Sobrecargas

CompareTo(Object)

Compara esta instância a um objeto especificado e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64)

Compara essa instância a um inteiro sem sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro sem sinal de 64 bits.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

CompareTo(Int64)

Compara essa instância a um inteiro com sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro com sinal de 64 bits.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(BigInteger)

Compara esta instância a um segundo BigInteger e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Object)

Compara esta instância a um objeto especificado e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

public:
 virtual int CompareTo(System::Object ^ obj);
public int CompareTo (object obj);
abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int
Public Function CompareTo (obj As Object) As Integer

Parâmetros

obj
Object

O objeto a ser comparado.The object to compare.

Retornos

Um inteiro com sinal que indica a relação da instância atual com o parâmetro obj, conforme mostrado na tabela a seguir.A signed integer that indicates the relationship of the current instance to the obj parameter, as shown in the following table.

Valor retornadoReturn value DescriçãoDescription
Menor que zeroLess than zero A instância atual é menor que obj.The current instance is less than obj.
ZeroZero A instância atual é igual a obj.The current instance equals obj.
Maior que zeroGreater than zero A instância atual é maior do que obj ou o parâmetro obj é null.The current instance is greater than obj, or the obj parameter is null.

Implementações

Exceções

obj não é um BigInteger.obj is not a BigInteger.

Exemplos

O exemplo a seguir chama o método CompareTo(Object) para comparar um valor de BigInteger com cada elemento em uma matriz de objetos:The following example calls the CompareTo(Object) method to compare a BigInteger value with each element in an object array:

object[] values = { BigInteger.Pow(Int64.MaxValue, 10), null, 
                    12.534, Int64.MaxValue, BigInteger.One };
BigInteger number = UInt64.MaxValue;

foreach (object value in values)
{
   try {
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value, 
                        number.CompareTo(value));
   }
   catch (ArgumentException) {
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value);
   }
}                                 
// The example displays the following output:
//    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
//    Comparing 18446744073709551615 with '': 1
//    Unable to compare the Double value 12.534 with a BigInteger.
//    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
//    Comparing 18446744073709551615 with '1': 1
Dim values() As Object = { BigInteger.Pow(Int64.MaxValue, 10), Nothing, 
                           12.534, Int64.MaxValue, BigInteger.One }
Dim number As BigInteger = UInt64.MaxValue

For Each value As Object In values
   Try
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value, 
                        number.CompareTo(value))
   Catch e As ArgumentException
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value)
   End Try                     
Next                                 
' The example displays the following output:
'    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
'    Comparing 18446744073709551615 with '': 1
'    Unable to compare the Double value 12.534 with a BigInteger.
'    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
'    Comparing 18446744073709551615 with '1': 1

Comentários

Essa sobrecarga do método CompareTo implementa o método IComparable.CompareTo.This overload of the CompareTo method implements the IComparable.CompareTo method. Ele é usado por objetos de coleção não genéricos para ordenar os itens na coleção.It is used by non-generic collection objects to order the items in the collection.

O parâmetro obj deve ser um dos seguintes:The obj parameter must be one of the following:

  • Um objeto cujo tipo de tempo de execução é BigInteger.An object whose run-time type is BigInteger.

  • Uma variável Object cujo valor é null.An Object variable whose value is null. Se o valor do parâmetro obj for null, o método retornará 1, o que indica que a instância atual é maior que obj.If the value of the obj parameter is null, the method returns 1, which indicates that the current instance is greater than obj.

Veja também

CompareTo(UInt64)

Importante

Esta API não está em conformidade com CLS.

Compara essa instância a um inteiro sem sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro sem sinal de 64 bits.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

public:
 int CompareTo(System::UInt64 other);
[System.CLSCompliant(false)]
public int CompareTo (ulong other);
public int CompareTo (ulong other);
member this.CompareTo : uint64 -> int
Public Function CompareTo (other As ULong) As Integer

Parâmetros

other
UInt64

O inteiro sem sinal de 64 bits para comparar.The unsigned 64-bit integer to compare.

Retornos

Um inteiro com sinal que indica o valor relativo dessa instância e other, conforme mostrado na tabela a seguir.A signed integer that indicates the relative value of this instance and other, as shown in the following table.

Valor retornadoReturn valueDescriçãoDescription
Menor que zeroLess than zeroA instância atual é menor que other.The current instance is less than other.
ZeroZeroA instância atual é igual a other.The current instance equals other.
Maior que zeroGreater than zeroA instância atual é maior que other.The current instance is greater than other.
Atributos

CompareTo(Int64)

Compara essa instância a um inteiro com sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro com sinal de 64 bits.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

public:
 int CompareTo(long other);
public int CompareTo (long other);
member this.CompareTo : int64 -> int
Public Function CompareTo (other As Long) As Integer

Parâmetros

other
Int64

O inteiro com sinal de 64 bits para comparar.The signed 64-bit integer to compare.

Retornos

Um valor de inteiro com sinal que indica a relação desta instância com other, conforme mostrado na tabela a seguir.A signed integer value that indicates the relationship of this instance to other, as shown in the following table.

Valor retornadoReturn value DescriçãoDescription
Menor que zeroLess than zero A instância atual é menor que other.The current instance is less than other.
ZeroZero A instância atual é igual a other.The current instance equals other.
Maior que zeroGreater than zero A instância atual é maior que other.The current instance is greater than other.

Exemplos

O exemplo a seguir ilustra o resultado da chamada do método CompareTo(Int64) com valores integrais.The following example illustrates the result of calling the CompareTo(Int64) method with integral values.

BigInteger bigIntValue = BigInteger.Parse("3221123045552");

byte byteValue = 16;
sbyte sbyteValue = -16;
short shortValue = 1233;      
ushort ushortValue = 1233;
int intValue = -12233;
uint uintValue = 12233;
long longValue = 12382222;
ulong ulongValue = 1238222;

Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, byteValue, 
                  bigIntValue.CompareTo(byteValue));
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, sbyteValue, 
                  bigIntValue.CompareTo(sbyteValue)); 
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, shortValue, 
                  bigIntValue.CompareTo(shortValue));
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, ushortValue, 
                  bigIntValue.CompareTo(ushortValue)); 
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, intValue, 
                  bigIntValue.CompareTo(intValue));
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, uintValue, 
                  bigIntValue.CompareTo(uintValue)); 
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, longValue, 
                  bigIntValue.CompareTo(longValue));
Console.WriteLine("Comparing {0} with {1}: {2}", 
                  bigIntValue, ulongValue, 
                  bigIntValue.CompareTo(ulongValue));
// The example displays the following output:
//       Comparing 3221123045552 with 16: 1
//       Comparing 3221123045552 with -16: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with -12233: 1
//       Comparing 3221123045552 with 12233: 1
//       Comparing 3221123045552 with 12382222: 1
//       Comparing 3221123045552 with 1238222: 1
Dim bigIntValue As BigInteger = BigInteger.Parse("3221123045552")

Dim byteValue As Byte = 16
Dim sbyteValue As SByte = -16
Dim shortValue As Short = 1233      
Dim ushortValue As UShort = 1233
Dim intValue As Integer = -12233
Dim uintValue As UInteger = 12233
Dim longValue As Long = 12382222
Dim ulongValue As Integer = 1238222

Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, byteValue, _
                  bigIntValue.CompareTo(byteValue))
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, sbyteValue, _
                  bigIntValue.CompareTo(sbyteValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, shortValue, _
                  bigIntValue.CompareTo(shortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ushortValue, _
                  bigIntValue.CompareTo(ushortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, intValue, _
                  bigIntValue.CompareTo(intValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, uintValue, _
                  bigIntValue.CompareTo(uintValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, longValue, _
                  bigIntValue.CompareTo(longValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ulongValue, _
                  bigIntValue.CompareTo(ulongValue))
' The example displays the following output:
'       Comparing 3221123045552 with 16: 1
'       Comparing 3221123045552 with -16: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with -12233: 1
'       Comparing 3221123045552 with 12233: 1
'       Comparing 3221123045552 with 12382222: 1
'       Comparing 3221123045552 with 1238222: 1

Comentários

Se other for um valor de Byte, Int16, Int32, SByte, UInt16ou UInt32, ele será convertido implicitamente em um valor de Int64 quando o método CompareTo(Int64) for chamado.If other is a Byte, Int16, Int32, SByte, UInt16, or UInt32 value, it is implicitly converted to an Int64 value when the CompareTo(Int64) method is called.

CompareTo(BigInteger)

Compara esta instância a um segundo BigInteger e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

public:
 virtual int CompareTo(System::Numerics::BigInteger other);
public int CompareTo (System.Numerics.BigInteger other);
abstract member CompareTo : System.Numerics.BigInteger -> int
override this.CompareTo : System.Numerics.BigInteger -> int
Public Function CompareTo (other As BigInteger) As Integer

Parâmetros

other
BigInteger

O objeto a ser comparado.The object to compare.

Retornos

Um valor de inteiro com sinal que indica a relação desta instância com other, conforme mostrado na tabela a seguir.A signed integer value that indicates the relationship of this instance to other, as shown in the following table.

Valor retornadoReturn value DescriçãoDescription
Menor que zeroLess than zero A instância atual é menor que other.The current instance is less than other.
ZeroZero A instância atual é igual a other.The current instance equals other.
Maior que zeroGreater than zero A instância atual é maior que other.The current instance is greater than other.

Implementações

Exemplos

O exemplo a seguir ilustra o uso do método CompareTo(BigInteger) para ordenar uma lista de objetos StarInfo.The following example illustrates the use of the CompareTo(BigInteger) method to order a list of StarInfo objects. Cada objeto de StarInfo fornece informações sobre o nome de uma estrela e sua distância da terra em milhas.Each StarInfo object provides information about a star's name and its distance from the Earth in miles. StarInfo implementa a interface IComparable<T>, que permite que StarInfo objetos sejam classificados por classes de coleção genéricas.StarInfo implements the IComparable<T> interface, which enables StarInfo objects to be sorted by generic collection classes. Sua implementação de IComparable<T>.CompareTo apenas encapsula uma chamada para CompareTo(BigInteger).Its IComparable<T>.CompareTo implementation just wraps a call to CompareTo(BigInteger).

using System;
using System.Collections.Generic;
using System.Numerics;

public struct StarInfo : IComparable<StarInfo>
{
   // Define constructors.
   public StarInfo(string name, double lightYears)
   {
      this.Name = name;
      
      // Calculate distance in miles from light years.
      this.Distance = (BigInteger) Math.Round(lightYears * 5.88e12);
   }

   public StarInfo(string name, BigInteger distance)
   {
      this.Name = name;
      this.Distance = distance;
   }

   // Define public fields.
   public string Name;
   public BigInteger Distance;

   // Display name of star and its distance in parentheses.
   public override string ToString()
   {
      return String.Format("{0,-10} ({1:N0})", this.Name, this.Distance);
   }

   // Compare StarInfo objects by their distance from Earth.
   public int CompareTo(StarInfo other)
   {
      return this.Distance.CompareTo(other.Distance);
   }
}
Imports System.Collections.Generic
Imports System.Numerics

Public Structure StarInfo : Implements IComparable(Of StarInfo)
   ' Define constructors.
   Public Sub New(name As String, lightYears As Double)
      Me.Name = name
      ' Calculate distance in miles from light years.
      Me.Distance = CType(Math.Round(lightYears * 5.88e12), BigInteger)
   End Sub
   
   Public Sub New(name As String, distance As BigInteger)
      Me.Name = name
      Me.Distance = distance
   End Sub
   
   ' Define public fields.
   Public Name As String
   Public Distance As BigInteger

   ' Display name of star and its distance in parentheses.
   Public Overrides Function ToString() As String
      Return String.Format("{0,-10} ({1:N0})", Me.Name, Me.Distance)
   End Function

   ' Compare StarInfo objects by their distance from Earth.
   Public Function CompareTo(other As starInfo) As Integer _
                   Implements IComparable(Of StarInfo).CompareTo
      Return Me.Distance.CompareTo(other.Distance)
   End Function                
End Structure

Em seguida, o código a seguir instancia quatro objetos StarInfo e os armazena em um objeto List<T> genérico.The following code then instantiates four StarInfo objects and stores them in a generic List<T> object. Depois que o método List<T>.Sort for chamado, StarInfo objetos serão exibidos em ordem de distância da terra.After the List<T>.Sort method is called, StarInfo objects are displayed in order of their distance from the Earth.

public class Example
{
   public static void Main()
   {
      StarInfo star;
      List<StarInfo> stars = new List<StarInfo>();

      star = new StarInfo("Sirius", 8.6d);
      stars.Add(star);
      star = new StarInfo("Rigel", 1400d);
      stars.Add(star);
      star = new StarInfo("Castor", 49d);
      stars.Add(star);
      star = new StarInfo("Antares", 520d);
      stars.Add(star);

      stars.Sort();

      foreach (StarInfo sortedStar in stars)
         Console.WriteLine(sortedStar);
   }
}
// The example displays the following output:
//       Sirius     (50,568,000,000,000)
//       Castor     (288,120,000,000,000)
//       Antares    (3,057,600,000,000,000)
//       Rigel      (8,232,000,000,000,000)
Module Example
   Public Sub Main()
      Dim star As StarInfo
      Dim stars As New List(Of StarInfo)
      
      star = New StarInfo("Sirius", 8.6d)
      stars.Add(star)
      star = New StarInfo("Rigel", 1400d)
      stars.Add(star)
      star = New StarInfo("Castor", 49d)
      stars.Add(star)
      star = New StarInfo("Antares", 520d)
      stars.Add(star)
      
      stars.Sort()
      
      For Each star In stars
         Console.WriteLine(star)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Sirius     (50,568,000,000,000)
'       Castor     (288,120,000,000,000)
'       Antares    (3,057,600,000,000,000)
'       Rigel      (8,232,000,000,000,000)

Comentários

Essa sobrecarga do método CompareTo implementa o método IComparable<T>.CompareTo.This overload of the CompareTo method implements the IComparable<T>.CompareTo method. Ele é usado por objetos de coleção genéricos para ordenar os itens na coleção.It is used by generic collection objects to order the items in the collection.

Veja também

Aplica-se a